<template>
  <div
    style="position: relative"
    v-loading="isLoadingDefaultRoute"
    element-loading-text="加载中请稍后..."
  >
    <div id="map-container" ref="mapContainer"></div>
    <div class="takeoff-point" v-if="shouldShowTakeoffTip">
      点击地图设置起飞点
    </div>
    <div class="tips">
      <p style="display: flex; align-items: center">
        点击图标
        <RouteIcon name="draw" width="18" />
        进行绘制/取消绘制航线
      </p>
      <p>ALT加左键拖动调整航点高度</p>
      <p>鼠标右键删除航点/航线</p>
      <p>鼠标左键拖动底部坐标调整位置</p>
    </div>
    <!-- 删除按钮 -->
    <div
      v-if="showDeleteButton"
      class="delete-button delete-confirm-btn"
      @click.stop
      @mousedown.stop
      :style="{
        left: deleteButtonPosition.x + 'px',
        top: deleteButtonPosition.y + 'px',
      }"
    >
      <p @click.stop="deleteWaypoint" style="padding: 0 4px; font-size: 12px">
        删除
      </p>
    </div>

    <linemap
      ref="mapviewRef"
      :previousPitch="previousPitch"
      :drawing_mode="drawing_mode"
      @viewClick="getviewClick"
      @mapsizeClick="getmapsizeClick"
      @mouseDrawClick="getmouseDrawClick"
      @viewcenterClick="getviewcenterClick"
      @mapTypeClick="getmapTypeClick"
      @getsearchClick="getsearchClick"
      @selectItem="getselectItem"
    ></linemap>
    <!-- <flaymap></flaymap> -->
  </div>
</template>
<script type="text/javascript">
// 必须在AMap JS加载前设置安全配置
window._AMapSecurityConfig = {
  securityJsCode: mapSetting.mapSecurity || "",
};
</script>
<script setup>
import {
  ref,
  watch,
  onMounted,
  onBeforeUnmount,
  defineProps,
  computed,
  onUnmounted,
  nextTick
} from "vue";
import { useRoute } from "vue-router";
import AMapLoader from "@amap/amap-jsapi-loader";
import { ElIcon, ElInput, ElSelect, ElButton, ElMessage } from "element-plus";
import linemap from "./linemap.vue";
// import flaymap from "./flaymap.vue";
import RouteIcon from "./iocn.vue";
import "./mapdata.css";
import { mapSetting } from "#/api/map";
const mapviewRef = ref();
const geocoder = ref(null); // 地理编码器实例
const tipInput = ref(""); // 检索关键字
const autoComplete = ref(null);
const placeSearch = ref(null);
const address = ref();
const point = ref([]);
const props = defineProps({
  flayShow: Boolean,
  flayoneShow: Boolean,
  flightaltitude: {
    type: Number,
    default: 120, // 默认海拔高度
  },
  drawDefaultRoute: {
    type: Array,
    default: () => [], // 默认航线数据
  },
  safetakeoffaltitude: {
    type: Number,
    default: 120, // 默认起飞高度
  },
  airlineList: {
    type: Array,
    default: () => [], // 更新各个航点高度
  },
  selectedWayPoint: {
    type: Object,
    default: () => {}, // 选中航点
  },
  airportList: {
    type: Array,
    default: () => [], // 机场列表
  },
  // airlineform: {
  //   type: Object,
  //   default: () => {}, // 航线表单
  // },//
});
const emit = defineEmits([
  "delSetTakeoffMode",
  "deloneSetTakeoffMode",
  "allData",
  "totalDistance",
  "distanceArray",
  "waypointCoordinateUpdated", // 新增：航点坐标更新事件
  "updateSearchInfo",
  "waypointDoubleClick", // 新增：航点双击事件
  "drawingnext", // 新增：绘制航线状态
]);
// 获取路由参数
const route = useRoute();
const map = ref(null); // 地图实例
const loca = ref(null); // 实例
const mapContainer = ref(null); //地图绑定参数
const searchMarker = ref(null); // 搜索标记
const defaultCenter = [119.904953, 30.251849]; // 在组件顶部定义默认中心点
const rotationAngle = ref(0);
const previousPitch = ref(0); // 跟踪之前的pitch值 // 旋转角度
const isAutoSwitching = ref(false); // 防止自动切换循环的标志
const isMapInitialized = ref(false); // 地图是否已初始化完成
const hasUserInteracted = ref(false); // 用户是否已经进行过任何操作
const isFirstTimeTakeoff = ref(true); // 是否是首次设置起飞点
const isResetMode = ref(false); // 是否处于重设模式
const isExitingFirstTimeMode = ref(false); // 是否正在退出首次设置模式
const isLoadingDefaultRoute = ref(false); // 是否正在加载默认航线
// 修复图层相关变量定义
let AMap = null; // 全局AMap引用
const allData = ref([
  {
    points: [],
    lineData: [],
    guideLineData: [],
    startdata: {
      point: null,
      lineData: null,
      guideLineData: null,
      marker: null,
    },
  },
]);
const startdata = ref({
  point: null,
  lineData: null,
  guideLineData: null,
  marker: null,
});
const pointsList = ref([]);
const lineData = ref([]);
const guideLineData = ref([]);
const distanceArray = ref([]); //距离数组
const bottomPoints = ref([]); //底部坐标
// 删除按钮相关
const showDeleteButton = ref(false);
const deleteButtonPosition = ref({ x: 0, y: 0 });
const selectedWaypointIndex = ref(-1);
// 距离计算相关
const totalDistance = ref(0); // 总距离（米）
// 新增状态变量
const isAltPressed = ref(false);
const isDraggingHeight = ref(false);
const startDragY = ref(0);
const originalHeight = ref(0);
const currentDraggingMarker = ref(null);
const is3DMode = ref(true);
const currentViewMode = ref(true); // true为3D模式，false为2D模式
let defaultHeight = 200; // 默认高度
const isDrawing = ref(false); // 是否正在绘制
const offset = 0; // 约1米偏移，确保线段可见
const drawing_mode = ref(2); // 绘制模式 1航线绘制 2起飞点绘制
const previousHeightMode = ref(300); // 跟踪之前的高度模式
const satelliteLayer = ref(null);
const roadNetLayer = ref(null);
// 初始化地图
const initMap = async () => {
  try {
    // 第一步：加载基础AMap
    AMap = await AMapLoader.load({
      key: mapSetting.mapKey,
      version: "2.0",
      plugins: [
        "AMap.PlaceSearch",
        "AMap.Geocoder",
        "AMap.AutoComplete",
        "AMap.ToolBar",
        "AMap.Scale",
        "AMap.Marker",
        "AMap.Geolocation",
        "AMap.Polyline",
        "AMap.BasicControl",
        "AMap.GetRotation",
        "AMap.ControlBar",
        "AMap.SetPitch",
        "AMap.Circle",
      ],
      features: ["bg", "building", "road"],
    });
    // 创建地图实例
    map.value = new AMap.Map(mapContainer.value, {
      zoom: 18,
      center: defaultCenter, //默认中心点
      viewMode: "3D",
      pitch: 50,
      rotateEnable: true, // 启用旋转
      dragEnable: true, // 启用拖拽
      zoomEnable: true, // 启用缩放
      doubleClickZoom: false, // 禁用双击放大，防止在设置起飞点时意外放大地图
      // layers: layers.value,
    });
    satelliteLayer.value = new AMap.TileLayer.Satellite();
    roadNetLayer.value = new AMap.TileLayer.RoadNet();
    //批量添加图层
    map.value.add([satelliteLayer.value, roadNetLayer.value]);
    if (!window.Loca) {
      await new Promise((resolve, reject) => {
        const script = document.createElement("script");
        script.src =
          "https://webapi.amap.com/loca?v=2.0&key=4382d57ce20d54c12e3c78ae23f76876";
        script.onload = resolve;
        script.onerror = reject;
        document.head.appendChild(script);
      });
    }
    // 2. 用 window.Loca 创建实例
    loca.value = new window.Loca.Container({ map: map.value });
    flayLine(loca.value);

    // 初始化地理编码器
    if (AMap && AMap.Geocoder) {
      geocoder.value = new AMap.Geocoder({
        city: "010", //城市设为北京，默认："全国"
        radius: 1000, //范围，默认：500
      });
    }
    // 搜索框自动完成类
    if (AMap && AMap.AutoComplete) {
      autoComplete.value = new AMap.AutoComplete({
        input: "keyword", // input 为绑定输入提示功能的input的DOM ID
      });
    }
    // 构造地点查询类
    if (AMap && AMap.PlaceSearch) {
      placeSearch.value = new AMap.PlaceSearch({
        map: map.value,
      });
    }

    createAirportMarker(); // 创建机场标记
    bindMapEvents(); // 绑定地图事件
    // 添加旋转事件监听
    initRotationListeners();
    // 添加键盘和鼠标事件监听
    window.addEventListener("keydown", handleKeyDown);
    window.addEventListener("keyup", handleKeyUp);
    // 初始化zoom监听器，设置辅助线粗细
    zoomChange();
    // 设置地图初始化完成标志
    isMapInitialized.value = true;

    // 地图初始化完成后的回调
    map.value.on("complete", () => {
      // 确保地图完全加载后再创建机场标记
      setTimeout(() => {
        createAirportMarker();
      }, 200);
    });

    // 如果地图已经完成加载，直接创建机场标记
    if (map.value && map.value.getCenter()) {
      setTimeout(() => {
        createAirportMarker();
      }, 300);
    }
    // 如果输入框已经有值，初始化时触发一次搜索
    if (tipInput.value && placeSearch.value) {
      placeSearch.value.search(tipInput.value);
    }
  } catch (error) {
    console.error("地图初始化失败:", error);
  }
};
// 创建机场标记
const createAirportMarker = () => {
  if (!map.value) return;

  // 先清除已存在的机场标记
  if (window.airportMarkers && window.airportMarkers.length > 0) {
    window.airportMarkers.forEach((marker) => {
      map.value.remove(marker);
    });
  }

  window.airportMarkers = []; // 存储机场标记的全局变量

  if (props.airportList && props.airportList.length > 0) {
    try {
      props.airportList.forEach((airport) => {
        // 验证机场数据
        if (!airport.longitude || !airport.latitude) {
          console.warn("机场数据缺少经纬度信息:", airport);
          return;
        }

        const text = new AMap.Marker({
          position: [airport.longitude, airport.latitude],
          content: `<div class="airport-marker">
              <img src="/static/blueairport.png" width="40" height="40" style="display: block;" />
              <p style="margin: 2px 0 0 0; line-height: 1;">${airport.airportName}</p>
           </div>`,
          offset: new AMap.Pixel(-20, -30),
          zIndex: 0,
        });

        map.value.add(text);
        window.airportMarkers.push(text); // 保存引用以便后续清除
      });

      // 设置地图中心点到第一个机场（仅在首次加载时）
      if (!hasUserInteracted.value) {
        let center = [
          props.airportList[0].longitude,
          props.airportList[0].latitude,
        ];
        map.value.setCenter(center);
      }
    } catch (error) {
      console.error("创建机场图标时出错:", error);
    }
  } else {
    console.warn("机场列表为空或未定义");
  }
};
// 监听机场列表变化
watch(
  () => props.airportList,
  (newAirportList) => {
    if (map.value && newAirportList) {
      // 延迟执行以确保地图完全初始化
      setTimeout(() => {
        createAirportMarker();
      }, 100);
    }
  },
  { deep: true }
);
// 防止重复调用的标志
let isDrawingDefaultRoute = false;

// 根据默认数据绘制航线
const drawDefaultRoute = (defaultData) => {
  // 防止重复调用
  if (isDrawingDefaultRoute) {
    return;
  }

  isDrawingDefaultRoute = true;

  hasUserInteracted.value = true; // 标记用户已进行交互（加载默认数据）
  if (!map.value || !AMap) {
    console.error("地图未初始化");
    isDrawingDefaultRoute = false;
    return;
  }
  // 确保有默认数据
  if (!defaultData) {
    console.error("默认数据格式错误");
    isDrawingDefaultRoute = false;
    return;
  }

  // 初始化航线数据结构
  allData.value = [
    {
      name: "默认航线",
      startdata: {
        lineData: null,
        guideLineData: null,
        point: [],
        marker: null,
      },
      lineData: [],
      guideLineData: [],
      points: [],
      markers: [],
    },
  ];

  // 处理起飞点
  if (defaultData.startdata && defaultData.startdata.point) {
    const takeoffPoint = defaultData.startdata.point;
    allData.value[0].startdata.point = takeoffPoint;
    // 如果有默认起飞点，标记不是首次设置
    isFirstTimeTakeoff.value = false;

    // 创建起飞点标记
    const takeoffMarker = new AMap.Marker({
      position: [takeoffPoint[0], takeoffPoint[1]],
      content: `<div style="display:flex;align-items:center;justify-content:center;width:30px;height:30px;font-weight:bold;color:white;background:#fff;border-radius:50%;"><img src="/static/flay.png" width="24" height="24" /></div>`,
      offset: new AMap.Pixel(-20, -20),
      extData: {
        altitude: 0, // 起飞点标记保持在地面
        index: -1,
        originalPosition: [takeoffPoint[0], takeoffPoint[1]],
      },
      draggable: true, // 允许起飞点拖动
    });

    map.value.add(takeoffMarker);
    render_marker_height(takeoffMarker);
    allData.value[0].startdata.marker = takeoffMarker;

    // 保存起飞点的原始位置，用于后续保护
    const originalTakeoffPosition = [takeoffPoint[0], takeoffPoint[1]];
    window.originalTakeoffPosition = originalTakeoffPosition;

    // 创建起飞点辅助线 - 改为Point类型
    if (takeoffPoint && takeoffPoint.length >= 3) {
      allData.value[0].startdata.guideLineData = {
        type: "Feature",
        geometry: {
          type: "Point",
          coordinates: [
            arithmetic.subtract(takeoffPoint[0], offset),
            takeoffPoint[1],
          ], // 地面点坐标
        },
        properties: {
          color: "#00d58f",
          isStartGuideLine: true,
          h: takeoffPoint[2], // 使用h属性，与mapvvvv.html保持一致
        },
      };
    }

    // 添加起飞点鼠标悬停事件 - 显示拖动光标
    takeoffMarker.on("mouseover", (e) => {
      if (map.value) {
        map.value.getContainer().style.cursor = "move";
      }
    });

    takeoffMarker.on("mouseout", (e) => {
      if (map.value) {
        // 恢复默认光标样式
        if (drawing_mode.value == 2) {
          map.value.getContainer().style.cursor = "crosshair";
        } else {
          map.value.getContainer().style.cursor = isDrawing.value
            ? "crosshair"
            : "default";
        }
      }
    });

    // 添加起飞点拖动事件
    takeoffMarker.on("dragstart", (e) => {
      // 拖动开始时设置光标为move
      if (map.value) {
        map.value.getContainer().style.cursor = "move";
      }
    });

    takeoffMarker.on("dragging", (e) => {
      const extData = takeoffMarker.getExtData();
      const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

      // 起飞点只支持正常拖动，不支持高度调整
      extData.originalPosition = [newPosition[0], newPosition[1]];
      takeoffMarker.setExtData(extData);

      // 使用安全起飞高度，而不是extData.altitude
      const takeoffHeight =
        props.safetakeoffaltitude || allData.value[0].startdata.point[2] || 300;

      allData.value[0].startdata.point = [
        newPosition[0],
        newPosition[1],
        takeoffHeight,
      ];

      updateLineAndGuideLine(
        [newPosition[0], newPosition[1], takeoffHeight],
        extData
      );
    });
    
    takeoffMarker.on("dragend", (e) => {
      // 拖动结束时恢复光标样式
      if (map.value) {
        if (drawing_mode.value == 2) {
          map.value.getContainer().style.cursor = "crosshair";
        } else {
          map.value.getContainer().style.cursor = isDrawing.value
            ? "crosshair"
            : "default";
        }
      }
    });
  }

  // 处理航点 - 支持多种数据格式
  let waypoints = [];
  if (defaultData.points && Array.isArray(defaultData.points)) {
    waypoints = defaultData.points;
  } else if (defaultData.point && Array.isArray(defaultData.point)) {
    // 如果数据格式是 point 数组
    waypoints = defaultData.point;
  }

  if (waypoints.length > 0) {
    waypoints.forEach((point, index) => {
      // 确保点数据格式正确 [lng, lat, height]
      const waypoint = Array.isArray(point)
        ? point
        : [
            point.lng || point[0],
            point.lat || point[1],
            point.height || point[2] || defaultHeight,
          ];

      // 添加航点标记
      const marker = new AMap.Marker({
        position: [waypoint[0], waypoint[1]],
        content: `<div style="position:relative;">
          <div class="line-tooltip">
            <div>ASL: ${waypoint[2]}m</div>
            <div>HAE: ${waypoint[2]}m</div>
          </div>
          <div class="marker-index">${index + 1}</div>
        </div>`,
        offset: new AMap.Pixel(-15, -15),
        extData: {
          altitude: waypoint[2],
          index: index,
          originalPosition: [waypoint[0], waypoint[1]],
        },
        draggable: true, // 空中航点拖动
      });

      map.value.add(marker);

      // 在2D模式下隐藏空中航点
      if (!currentViewMode.value) {
        marker.hide();
      }

      render_marker_height(marker);
      addMarkerTooltip(marker, "航点");

      // 添加单击事件（右键删除）
      marker.on("click", (e) => {
        const originalEvent = e.originalEvent || e;
        if (originalEvent.button === 2) {
          showDeleteButtonHandler(originalEvent, index);
          originalEvent.preventDefault();
          return;
        }
      });

      // 添加双击事件 - 使用AMap原生的dblclick事件
      marker.on("dblclick", (e) => {
        // 双击事件 - 将航点数据传给父元素
        const position = marker.getPosition();
        const extData = marker.getExtData();
        const waypointData = {
          lng: position.lng,
          lat: position.lat,
          altitude: extData.altitude || 0,
          index: extData.index,
        };

        // 发送给父组件
        emit("waypointDoubleClick", waypointData);
      });

      marker.on("rightclick", (e) => {
        showDeleteButtonHandler(e, index);
      });

      marker.on("contextmenu", (e) => {
        if (e.originalEvent) {
          e.originalEvent.preventDefault();
        }
      });
      // 添加拖动事件
      marker.on("dragging", (e) => {
        const extData = marker.getExtData();
        const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

        // 空中航点只有在按下Alt键时才允许拖动
        if (!isAltPressed.value) {
          // 如果没有按Alt键，阻止拖动，回到原位置
          marker.setPosition([
            extData.originalPosition[0],
            extData.originalPosition[1],
            extData.altitude,
          ]);
          return;
        }

        if (isAltPressed.value && isDraggingHeight.value) {
          // 高度调整模式
          const heightChange = (startDragY.value - e.pixel.y) * 0.5;
          const newHeight = Math.max(0, originalHeight.value + heightChange);

          extData.altitude = newHeight;
          marker.setExtData(extData);

          marker.setPosition([
            extData.originalPosition[0],
            extData.originalPosition[1],
            newHeight,
          ]);
          render_marker_height(marker);

          // 更新 points 数组
          allData.value[0].points[index] = [
            extData.originalPosition[0],
            extData.originalPosition[1],
            newHeight,
          ];

          updateLineAndGuideLine(
            [
              extData.originalPosition[0],
              extData.originalPosition[1],
              newHeight,
            ],
            extData
          );
        } else if (isAltPressed.value) {
          // 正常拖动模式 - 只有按下Alt键时才允许
          extData.originalPosition = [newPosition[0], newPosition[1]];
          marker.setExtData({
            ...extData,
            altitude: newPosition[2] || extData.altitude,
          });

          allData.value[0].points[index] = [
            newPosition.lng,
            newPosition.lat,
            extData.altitude,
          ];

          updateMarker(
            [newPosition.lng, newPosition.lat, extData.altitude],
            extData
          );
          updateLineAndGuideLine(
            [newPosition.lng, newPosition.lat, extData.altitude],
            extData
          );
        }
      });

      // 添加鼠标事件
      marker.on("mousedown", (e) => {
        const originalEvent = e.originalEvent || e.originEvent || e;
        if (isAltPressed.value && originalEvent && originalEvent.button === 0) {
          startHeightDrag(marker, originalEvent.clientY);
        }
      });

      marker.on("mouseup", () => {
        if (isDraggingHeight.value) {
          endHeightDrag();
        }
      });

      // 添加到数组
      allData.value[0].markers.push(marker);
      allData.value[0].points.push(waypoint);

      // 创建航点辅助线 - 改为Point类型
      if (waypoint && waypoint.length >= 3) {
        allData.value[0].guideLineData.push({
          type: "Feature",
          geometry: {
            type: "Point",
            coordinates: [
              arithmetic.subtract(waypoint[0], offset),
              waypoint[1],
            ], // 地面点坐标
          },
          properties: {
            color: "#f4ed7c",
            h: waypoint[2], // 使用h属性，与mapvvvv.html保持一致
          },
        });
      }
    });

    for (let i = 0; i < allData.value[0].points.length - 1; i++) {
      const start = allData.value[0].points[i];
      const end = allData.value[0].points[i + 1];
      const segmentDistance = calculateDistance(start, end);

      allData.value[0].lineData.push({
        type: "Feature",
        geometry: {
          type: "LineString",
          coordinates: [
            [start[0], start[1], start[2]],
            [end[0], end[1], end[2]],
          ],
        },
        properties: {
          color: "#3366ff",
          distance: segmentDistance,
        },
      });
    }

    // 如果有起飞点和航点，创建起飞点连接线
    if (
      allData.value[0].startdata.point &&
      allData.value[0].startdata.point.length > 0 &&
      allData.value[0].points.length > 0
    ) {
      const startPoint = allData.value[0].startdata.point;
      const firstWaypoint = allData.value[0].points[0];
      const segmentDistance = calculateDistance(startPoint, firstWaypoint);

      allData.value[0].startdata.lineData = {
        type: "Feature",
        geometry: {
          type: "LineString",
          coordinates: [startPoint, firstWaypoint],
        },
        properties: {
          color: "#3366ff",
          distance: segmentDistance,
        },
      };
    }
  }

  // 重新渲染图层
  RenderinglineLayer();
  RenderingguideLineLayer();

  // 更新距离标签
  clearDistanceMarkers();
  updateDistanceLabels();

  // 重新计算总距离
  calculateTotalDistance();

  // 通知父组件数据更新
  // console.log("更新数据1", allData.value);
  emit("allData", allData.value);
  emit("totalDistance", totalDistance.value);

  // 将地图中心点设置为起飞点位置
  if (
    allData.value[0].startdata.point &&
    allData.value[0].startdata.point.length > 0
  ) {
    const takeoffPoint = allData.value[0].startdata.point;

    map.value.setCenter([takeoffPoint[0], takeoffPoint[1]]);
    map.value.setZoom(16); // 设置合适的缩放级别
  }

  // 设置绘制模式为航线绘制，但不启用绘制状态（让用户手动控制）
  drawing_mode.value = 1; // 设置为航线绘制模式，但不启用绘制状态
  isDrawing.value = false; // 不自动启用绘制状态，让用户手动控制
  map.value.getContainer().style.cursor = "default"; // 不自动设置鼠标样式

  // 渲染底部小圆点
  RenderingpointLayer();
  // 重置标志
  isDrawingDefaultRoute = false;
  // 清除加载状态
  isLoadingDefaultRoute.value = false;
  
  // 绘制完成后使用防抖发送数据更新事件
  nextTick(() => {
    debouncedEmitAllData();
    debouncedEmitTotalDistance(totalDistance.value);
    
    // 绘制完成后检查是否需要显示起飞点提示
    if (shouldShowTakeoffTip.value && map.value) {
      isDrawing.value = true;
      drawing_mode.value = 2; // 起飞点设置模式
      map.value.getContainer().style.cursor = "crosshair";
      
      // 确保添加起飞点点击监听器
      map.value.off("click", handleMapClickForTakeoff);
      map.value.on("click", handleMapClickForTakeoff);
    }
  });
};
// 设置浮空线段
const flayLine = (locaInstance) => {
  if (window.Loca && locaInstance) {
    try {
      // 创建 LineLayer（浮空线段）
      const lineLayer = new window.Loca.LineLayer({
        zIndex: 100, // 确保图层在上层
      });

      // 创建辅助线图层
      const guideLineLayer = new window.Loca.LaserLayer({
        zIndex: 55, // 确保辅助线在底层但可见
        zooms: [2, 20], //
      });

      // 设置 LineLayer 数据源
      lineLayer.setSource(
        new window.Loca.GeoJSONSource({
          data: {
            type: "FeatureCollection",
            features: [],
          },
        })
      );

      // 设置辅助线图层数据源
      guideLineLayer.setSource(
        new window.Loca.GeoJSONSource({
          data: {
            type: "FeatureCollection",
            features: [],
          },
        })
      );

      // 设置辅助线样式 - 使用静态线条
      guideLineLayer.setStyle({
        altitude: true, // 启用高度
        lineWidth: 3, // 线条宽度
        color: "#f0ed7a", // 黄色辅助线
      });

      // 设置 LineLayer 样式 浮空线段样式
      lineLayer.setStyle({
        altitude: true, // 启用高度
        lineWidth: 5, // 线段宽度
        color: "#00d58f", // 颜色属性名改为 color
      });

      // 将图层添加到loca容器
      locaInstance.add(lineLayer);
      locaInstance.add(guideLineLayer);

      // 保存图层引用到全局变量
      window.lineLayer = lineLayer;
      window.guideLineLayer = guideLineLayer;

      // 启动激光线动画
      if (locaInstance && locaInstance.animate) {
        locaInstance.animate.start();
      }
    } catch (error) {
      console.error("flayLine 创建图层时出错:", error);
    }
  } else {
    console.error("flayLine 条件不满足:");
    console.error("window.Loca:", window.Loca);
    console.error("locaInstance:", locaInstance);
  }
};
// 绑定地图事件
const bindMapEvents = (val) => {
  // 添加鼠标按下事件，如果鼠标不在删除按钮上就隐藏删除按钮
  map.value.on("mousedown", (e) => {
    // 检查鼠标按下是否在删除按钮上
    const target = e.originalEvent?.target;
    if (target && !target.closest(".delete-button")) {
      hideDeleteButton();
    }
  });
  // 阻止地图容器的默认右键菜单
  map.value.getContainer().addEventListener("contextmenu", (e) => {
    e.preventDefault();
  });
  map.value.on("click", function (ev) {
    // 检查点击是否在删除按钮上
    const target = ev.originalEvent?.target;
    if (target && !target.closest(".delete-button")) {
      hideDeleteButton();
    }
    // 如果有默认数据且不在绘制模式下，直接忽略点击
    if (
      props.drawDefaultRoute &&
      props.drawDefaultRoute.length > 0 &&
      !isDrawing.value
    ) {
      return;
    }
    // 如果不在绘制模式下，直接忽略点击
    if (!isDrawing.value) return;

    // 如果是起飞点设置模式，调用 handleMapClickForTakeoff 处理
    if (drawing_mode.value == 2) {
      // 如果有默认数据且不在绘制模式下，不处理起飞点设置
      if (
        props.drawDefaultRoute &&
        props.drawDefaultRoute.length > 0 &&
        !isDrawing.value
      ) {
        return;
      }
      if (typeof handleMapClickForTakeoff === "function") {
        handleMapClickForTakeoff(ev);
      }
      return;
    }

    // 如果显示起飞点提示且还没有起飞点，也可以设置起飞点
    if (shouldShowTakeoffTip.value && !allData.value[0]?.startdata?.point) {
      if (typeof handleMapClickForTakeoff === "function") {
        handleMapClickForTakeoff(ev);
      }
      return;
    }
    var lnglat = lnglatToNumber(ev.lnglat.KL, ev.lnglat.kT);
    const point = [lnglat[0], lnglat[1], defaultHeight]; //空中点坐标，限制精度
    addMarker(point); // 添加标点和辅助线
    let points = allData.value.length > 0 ? allData.value[0].points : []; //第一个航线的所有航点坐标
    let points2 =
      allData.value.length > 0 && allData.value[0].startdata?.point
        ? allData.value[0].startdata.point
        : []; //获取第一个航线的起飞点坐标
    // 创建起飞点到指定点的连接线 目标点坐标pp 起飞点坐标ppp默认值是 points2
    function startdata_lineData(pp, ppp = points2) {
      if (allData.value.length > 0) {
        // 计算起飞点连接线距离
        const segmentDistance = calculateDistance(ppp, pp);

        // 创建GeoJSON格式的线段数据
        allData.value[0].startdata.lineData = {
          type: "Feature", //Feature表示特征
          geometry: {
            type: "LineString", //LineString表示线
            coordinates: [ppp, pp], //ppp是起飞点坐标，pp是目标点坐标
          },
          properties: {
            color: "#3366ff",
            distance: segmentDistance, // 添加距离属性
          },
        };
        // 为起飞点连接线添加距离标签
        addLine(ppp, pp, true);
      }
    }
    // 航线绘制模式
    if (drawing_mode.value == 1) {
      // 航线绘制模式下，如果航点存在，则添加航点
      if (points.length > 0) {
        // 添加航线
        addLine(points[points.length - 1], point);
        // 如果有起飞点且还没有连接线，则创建连接线
        if (
          points2.length > 0 &&
          allData.value.length > 0 &&
          !allData.value[0].startdata.lineData
        ) {
          startdata_lineData(points[0]); // 连接到航线起点
        }
      }
      // 如果没有航点但有起飞点，直接连接到新点
      else if (points2.length > 0) {
        startdata_lineData(point);
      }
      // 添加航点
      points.push(point);
      if (allData.value.length > 0) {
        allData.value[0].points = points;
      }
      drawing_mode.value = 1;
      // 更新距离标签
      clearDistanceMarkers();
      updateDistanceLabels();
      // 重新计算总距离
      calculateTotalDistance();
      // 通知父组件数据更新
      // console.log("更新数据2", allData.value);
      allData.value[0].type = "add";
      emit("allData", allData.value);
      emit("totalDistance", totalDistance.value);

      // 只有在没有默认数据时才启用绘制模式
      // 如果有默认数据，保持 isDrawing = false，避免意外添加航点
      if (!props.drawDefaultRoute || props.drawDefaultRoute.length === 0) {
        getmouseDrawClick(true);
      }

      // 确保更新底部标记
      RenderingpointLayer();
    } else if (drawing_mode.value == 2) {
      if (points.length > 0 && allData.value.length > 0) {
        allData.value[0].startdata.point = [lnglat[0], lnglat[1], points[0][2]];
        startdata_lineData(points[0], allData.value[0].startdata.point);
        // 更新距离标签
        clearDistanceMarkers();
        updateDistanceLabels();
        // 重新计算总距离
        calculateTotalDistance();
        // 通知父组件数据更新
        // console.log("更新数据3", allData.value);
        emit("allData", allData.value);
        emit("totalDistance", totalDistance.value);
        // 更新数据源并重新渲染
        RenderinglineLayer();
        getmouseDrawClick(false); //取消绘制
      } else if (allData.value.length > 0 && drawing_mode.value == 2) {
        // 只有在起飞点设置模式下，且明确是设置起飞点时才赋值
        allData.value[0].startdata.point = point;
        drawing_mode.value = 1;
        getmouseDrawClick(true);
      }

      // 确保更新底部标记
      RenderingpointLayer();
    }
  });
};
// 添加zoom监听器 设置辅助线样式
const zoomChange = () => {
  map.value.on("zoomend", function () {
    const currentZoom = map.value.getZoom();
    let newLineWidth;
    // 根据zoom级别设置线条粗细，zoom越大线条越细
    if (currentZoom >= 19.5) {
      newLineWidth = 0.7; // 最高级别，最细线条
    } else if (currentZoom >= 19) {
      newLineWidth = 1.0;
    } else if (currentZoom >= 18.5) {
      newLineWidth = 1.2;
    } else if (currentZoom >= 18) {
      newLineWidth = 1.6;
    } else if (currentZoom >= 17.5) {
      newLineWidth = 2.0;
    } else if (currentZoom >= 17) {
      newLineWidth = 3.0;
    } else if (currentZoom >= 16.5) {
      newLineWidth = 4.0;
    } else if (currentZoom >= 16) {
      newLineWidth = 6.0;
    } else {
      newLineWidth = 7.0; // 最低级别，最粗线条
    }
    // 重新设置辅助线样式 - 使用全局的 guideLineLayer
    if (window.guideLineLayer && allData.value.length > 0) {
      // 获取辅助线数据
      let arr = [];
      const route = allData.value[0];
      if (Array.isArray(route.guideLineData)) {
        arr = arr.concat(...route.guideLineData);
      }
      if (route.startdata?.guideLineData?.type) {
        arr.push(route.startdata.guideLineData);
      }

      // 重新设置数据源，保持静态辅助线效果并更新线条宽度
      window.guideLineLayer.setSource(
        new window.Loca.GeoJSONSource({
          data: {
            type: "FeatureCollection",
            features: arr,
          },
        }),
        {
          unit: "meter",
          height: (index, feature) => {
            return feature.properties.h || 0;
          },
          color: "#f0ed7a", // 黄色辅助线
          lineWidth: newLineWidth, // 使用新的线条宽度
          trailLength: 5000, // 设置为0，禁用流动效果
          repeat: 0, // 不重复
        }
      );
      // 重新渲染以应用新样式
      window.guideLineLayer.render();
    }
  });
};
// 计算两点之间的距离（米）
const calculateDistance = (point1, point2) => {
  // 计算3D空间的实际距离，包括高度差
  const lnglat1 = new AMap.LngLat(point1[0], point1[1]);
  const lnglat2 = new AMap.LngLat(point2[0], point2[1]);
  const horizontalDistance = lnglat1.distance(lnglat2); // 水平距离
  const heightDiff = Math.abs((point1[2] || 0) - (point2[2] || 0)); // 计算高度差
  const distance = Math.sqrt(
    horizontalDistance * horizontalDistance + heightDiff * heightDiff
  );
  return Math.round(distance); // 四舍五入到整数
};
// 计算总距离
const calculateTotalDistance = () => {
  if (allData.value.length === 0) {
    totalDistance.value = 0;
    distanceArray.value = []; // 清空距离数组
    return;
  }
  let distance = 0;
  const newDistanceArray = []; // 临时数组存储所有距离
  const route = allData.value[0];
  // 计算起飞点高度变化的距离（从地面到起飞点高度）
  if (route.startdata?.point && route.startdata.point.length > 0) {
    const takeoffHeight = route.startdata.point[2] || 0;
    distance += takeoffHeight; // 起飞点高度变化距离
    newDistanceArray.push(takeoffHeight); // 添加到距离数组
  }
  // 计算起飞点连接线距离
  if (route.startdata?.lineData?.geometry?.coordinates) {
    const [start, end] = route.startdata.lineData.geometry.coordinates;
    const segmentDistance = calculateDistance(start, end);
    distance += segmentDistance;
    newDistanceArray.push(segmentDistance); // 添加到距离数组
  }
  // 计算航点间线段距离
  if (route.lineData && Array.isArray(route.lineData)) {
    route.lineData.forEach((line, index) => {
      if (line.geometry && line.geometry.coordinates) {
        const [start, end] = line.geometry.coordinates;
        const segmentDistance = calculateDistance(start, end);
        distance += segmentDistance;
        newDistanceArray.push(segmentDistance); // 添加到距离数组
      }
    });
  }
  totalDistance.value = distance;
  distanceArray.value = newDistanceArray; // 更新距离数组
  // 发送总距离到父组件
  emit("totalDistance", distance);
  // 同时发送距离数组到父组件
  emit("distanceArray", distanceArray.value);
};
// 键盘事件处理 高度调整模式
const handleKeyDown = (e) => {
  if (e.key === "Alt") {
    isAltPressed.value = true;
    // 修改鼠标样式为上下箭头，但在重设起飞点模式下保持十字光标
    if (map.value) {
      if (drawing_mode.value == 2) {
        map.value.getContainer().style.cursor = "crosshair";
      } else {
        map.value.getContainer().style.cursor = "ns-resize";
      }
    }
  }
};
// 键盘事件处理 高度调整模式
const handleKeyUp = (e) => {
  if (e.key === "Alt") {
    isAltPressed.value = false;
    // 恢复鼠标样式
    if (map.value) {
      // 如果是重设起飞点模式，保持十字光标
      if (drawing_mode.value == 2) {
        map.value.getContainer().style.cursor = "crosshair";
      } else {
        map.value.getContainer().style.cursor = isDrawing.value
          ? "crosshair"
          : "default";
      }
    }
    // 结束高度拖动
    if (isDraggingHeight.value) {
      endHeightDrag();
    }
  }
};
// 开始绘制/取消绘制
const getmouseDrawClick = (value) => {
  emit("drawingnext", value);
  // 开始绘制
  if (value == true) {
    hasUserInteracted.value = true; // 标记用户已进行交互
    isDrawing.value = true;
    map.value.getContainer().style.cursor = "crosshair"; //鼠标样式
    // 设置绘制模式为航线绘制
    drawing_mode.value = 1;

    // 确保移除起飞点设置监听器，避免冲突
    map.value.off("click", handleMapClickForTakeoff);

    // 如果没有航线数据，创建一条航线
    if (allData.value.length === 0) {
      allData.value.push({
        name: "航线",
        startdata: {
          lineData: null,
          guideLineData: null,
          point: [],
          marker: null,
        },
        lineData: [],
        guideLineData: [],
        points: [],
        markers: [],
      });
    }

    // 如果是起飞点绘制模式，清除现有的起飞点
    if (drawing_mode.value == 2 && allData.value[0].startdata.marker) {
      allData.value[0].startdata.marker.setMap(null);
      allData.value[0].startdata.lineData = null;
      allData.value[0].startdata.guideLineData = null;
      RenderinglineLayer();
      RenderingguideLineLayer();
    }
  }
  //取消绘制
  else {
    // 取消绘制
    isDrawing.value = false;

    // 如果没有航点，清除起飞点
    if (allData.value.length > 0 && allData.value[0].points.length < 1) {
      if (allData.value[0].startdata.marker) {
        allData.value[0].startdata.marker.setMap(null);
      }
      allData.value[0].startdata.guideLineData = null;
      RenderinglineLayer();
      RenderingguideLineLayer();
    }

    map.value.getContainer().style.cursor = "default"; //鼠标样式
    // console.log("更新数据4", allData.value);
    emit("allData", allData.value);
    emit("totalDistance", totalDistance.value);
  }
};
// 添加线段
const addLine = (start, end, isStartData = false) => {
  // 添加浮在空中的线段
  if (allData.value.length > 0) {
    // 计算该段距离
    const segmentDistance = calculateDistance(start, end);

    if (!isStartData) {
      // 普通航点之间的线段
      let lineData = allData.value[0].lineData;
      lineData.push({
        type: "Feature",
        geometry: {
          type: "LineString",
          coordinates: [
            [start[0], start[1], start[2]], // 地面点（向左偏移）
            [end[0], end[1], end[2]], // 空中点（保持原位置）
          ],
        },
        properties: {
          color: "#3366ff",
          distance: segmentDistance, // 添加距离属性
        },
      });
      allData.value[0].lineData = lineData;
    } else {
      // 起飞点连接线 - 确保距离属性已设置
      if (allData.value[0].startdata.lineData) {
        allData.value[0].startdata.lineData.properties.distance =
          segmentDistance;
      }
    }

    // 更新数据源并重新渲染
    RenderinglineLayer();
  }
};
// 添加航点
const addMarker = (position) => {
  hasUserInteracted.value = true; // 标记用户已进行交互
  if (allData.value.length === 0) return;

  // 确保 allData 有正确的结构
  if (!allData.value[0].markers) {
    allData.value[0].markers = [];
  }
  if (!allData.value[0].points) {
    allData.value[0].points = [];
  }

  let markers = allData.value[0].markers;
  let index = markers.length;
  var marker = new AMap.Marker({
    position: [position[0], position[1]],
    content:
      drawing_mode.value == 1
        ? `<div style="position:relative;">
        <div class="line-tooltip">
        <div>ASL: ${position[2]}m</div>
        <div>HAE: ${position[2] + 0}m</div>
      </div>
      <div class="marker-index">${index + 1}</div> </div>`
        : `<div style="display:flex;align-items:center;justify-content:center;width:30px;height:30px;font-weight:bold;color:white;background:#fff;border-radius:50%;"><img src="/static/flay.png" width="24" height="24" /></div>`,
    offset: new AMap.Pixel(-20, -20), // 调整标识位置
    extData: {
      altitude: drawing_mode.value == 1 ? position[2] : 0, // 设置标识的高度
      index: drawing_mode.value == 1 ? index : -1,
      originalPosition: [position[0], position[1]], // 保存原始经纬度
    },
    draggable: true, // 禁用空中航点的拖动
  });
  map.value.add(marker);

  // 在2D模式下隐藏空中航点
  if (!currentViewMode.value) {
    marker.hide();
  }

  render_marker_height(marker); //高德地图的 Marker 支持三维高度（z 坐标）

  // 只为航点添加鼠标悬浮提示框和右键菜单
  if (drawing_mode.value == 1) {
    addMarkerTooltip(marker, "航点");

    // 添加单击事件（右键删除）
    marker.on("click", (e) => {
      const originalEvent = e.originalEvent || e;

      // 检查是否为右键
      if (originalEvent.button === 2) {
        // 右键
        showDeleteButtonHandler(originalEvent, index);
        originalEvent.preventDefault();
        return;
      }
    });

    // 添加双击事件 - 使用AMap原生的dblclick事件
    marker.on("dblclick", (e) => {
      // 双击事件 - 将航点数据传给父元素
      const position = marker.getPosition();
      const extData = marker.getExtData();
      const waypointData = {
        lng: position.lng,
        lat: position.lat,
        altitude: extData.altitude || 0,
        index: extData.index,
      };
      // 发送给父组件
      emit("waypointDoubleClick", waypointData);
    });

    // 直接监听右键事件
    marker.on("rightclick", (e) => {
      showDeleteButtonHandler(e, index);
    });

    // 阻止默认的右键菜单
    marker.on("contextmenu", (e) => {
      if (e.originalEvent) {
        e.originalEvent.preventDefault();
      }
    });
  }
  marker.on("dragging", (e) => {
    const extData = marker.getExtData();
    const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

    // 空中航点只有在按下Alt键时才允许拖动
    if (!isAltPressed.value) {
      // 如果没有按Alt键，阻止拖动，回到原位置
      marker.setPosition([
        extData.originalPosition[0],
        extData.originalPosition[1],
        extData.altitude,
      ]);
      return;
    }

    if (isAltPressed.value && isDraggingHeight.value) {
      // 高度调整模式 - 保持经纬度不变
      const pixel = map.value.lngLatToContainer([
        extData.originalPosition[0],
        extData.originalPosition[1],
      ]);

      // 计算高度变化 (每像素移动对应的高度变化量)
      const heightChange = (startDragY.value - e.pixel.y) * 0.5;
      const newHeight = Math.max(0, originalHeight.value + heightChange);

      // 更新高度
      extData.altitude = newHeight;
      marker.setExtData(extData);

      // 保持原始经纬度，只更新高度
      marker.setPosition([
        extData.originalPosition[0],
        extData.originalPosition[1],
        newHeight,
      ]);
      render_marker_height(marker);

      // 更新 points 数组中的坐标
      if (extData.index !== -1 && allData.value[0].points[extData.index]) {
        allData.value[0].points[extData.index] = [
          extData.originalPosition[0],
          extData.originalPosition[1],
          newHeight,
        ];
      }
      // 更新起飞点坐标（如果是起飞点）
      else if (extData.index === -1 && allData.value[0].startdata.point) {
        allData.value[0].startdata.point = [
          extData.originalPosition[0],
          extData.originalPosition[1],
          newHeight,
        ];
      }

      // 更新相关线段和辅助线
      updateLineAndGuideLine(
        [extData.originalPosition[0], extData.originalPosition[1], newHeight],
        extData
      );
    } else if (isAltPressed.value) {
      // 正常拖动模式 - 只有按下Alt键时才允许
      extData.originalPosition = [newPosition[0], newPosition[1]]; // 更新原始位置
      marker.setExtData({
        ...extData,
        altitude: newPosition[2] || extData.altitude,
      });

      // 更新 points 数组中的坐标（如果是航点）
      if (extData.index !== -1 && allData.value[0].points[extData.index]) {
        allData.value[0].points[extData.index] = [
          newPosition[0],
          newPosition[1],
          extData.altitude,
        ];
      }
      // 更新起飞点坐标（如果是起飞点）
      else if (extData.index === -1 && allData.value[0].startdata.point) {
        allData.value[0].startdata.point = [
          newPosition[0],
          newPosition[1],
          extData.altitude,
        ];
      }

      updateMarker([newPosition[0], newPosition[1], extData.altitude], extData);
      updateLineAndGuideLine(
        [newPosition[0], newPosition[1], extData.altitude],
        extData
      );
    }
  });
  // 添加鼠标按下事件
  marker.on("mousedown", (e) => {
    const originalEvent = e.originalEvent || e.originEvent || e;
    if (isAltPressed.value && originalEvent && originalEvent.button === 0) {
      // 左键
      startHeightDrag(marker, originalEvent.clientY);
    }
  });

  // 添加鼠标释放事件
  marker.on("mouseup", () => {
    if (isDraggingHeight.value) {
      endHeightDrag();
    }
  });
  if (drawing_mode.value == 1) {
    markers.push(marker);
    allData.value[0].markers = markers;
    // 添加辅助线 - 改为Point类型，从地面点创建激光线
    if (position && position.length >= 3) {
      allData.value[0].guideLineData.push({
        type: "Feature",
        geometry: {
          type: "Point",
          coordinates: [arithmetic.subtract(position[0], offset), position[1]], // 地面点坐标
        },
        properties: {
          color: "#f4ed7c",
          h: position[2], // 使用h属性，与mapvvvv.html保持一致
        },
      });
    }
  } else if (drawing_mode.value == 2) {
    allData.value[0].startdata.marker = marker;
    // 起飞点不需要悬浮提示功能
    // 添加/更新辅助线 - 改为Point类型
    if (position && position.length >= 3) {
      allData.value[0].startdata.guideLineData = {
        type: "Feature",
        geometry: {
          type: "Point",
          coordinates: [arithmetic.subtract(position[0], offset), position[1]], // 地面点坐标
        },
        properties: {
          color: "#00d58f", // 改为绿色
          isStartGuideLine: true, // 添加标识，表示这是起始点辅助线
          h: position[2], // 使用h属性，与mapvvvv.html保持一致
        },
      };
    }
  }

  // 更新数据源并重新渲染
  RenderingguideLineLayer();
  RenderingpointLayer(); // 确保在添加航点后更新底部标记

  // 重新计算总距离
  calculateTotalDistance();
  // 通知父组件数据更新
  // console.log("更新数据5", allData.value);
  allData.value[0].type = "add";
  emit("allData", allData.value);
  emit("totalDistance", totalDistance.value);
};
// 更新航点
const updateMarker = (lnglat, extData) => {
  if (allData.value.length === 0) return;

  if (extData.index != -1) {
    if (allData.value[0].markers[extData.index]) {
      allData.value[0].points[extData.index] = lnglat;
      allData.value[0].markers[extData.index].setPosition([
        lnglat[0],
        lnglat[1],
      ]);
      allData.value[0].markers[extData.index].setExtData({
        ...allData.value[0].markers[extData.index].getExtData(),
        altitude: lnglat[2],
      });
    }
    render_marker_height(allData.value[0].markers[extData.index]);
    // 重新计算总距离
    calculateTotalDistance();
    // 通知父组件数据更新
    // console.log("更新数据6", allData.value);
    emit("allData", allData.value);
    emit("totalDistance", totalDistance.value);

    // 确保更新底部标记
    RenderingpointLayer();
  } else {
    if (allData.value[0].startdata.marker) {
      allData.value[0].startdata.point = lnglat;
      allData.value[0].startdata.marker.setPosition([lnglat[0], lnglat[1]]);
      allData.value[0].startdata.marker.setExtData({
        ...allData.value[0].startdata.marker.getExtData(),
        altitude: lnglat[2],
      });
    }
    render_marker_height(allData.value[0].startdata.marker);
    // 重新计算总距离（起飞点更新时）
    calculateTotalDistance();
    // 通知父组件数据更新
    // console.log("更新数据7", allData.value);
    emit("allData", allData.value);
    emit("totalDistance", totalDistance.value);

    // 确保更新底部标记
    RenderingpointLayer();
  }
};
// 更新线段和辅助线
const updateLineAndGuideLine = (lnglat, extData) => {
  if (allData.value.length === 0) return;

  // 确保 allData 有正确的结构
  if (!allData.value[0].points) {
    allData.value[0].points = [];
  }
  if (!allData.value[0].startdata) {
    allData.value[0].startdata = {
      point: null,
      lineData: null,
      guideLineData: null,
      marker: null,
    };
  }

  // extData 参数说明:
  // index 标点索引
  let points = allData.value[0].points;
  let points2 = allData.value[0].startdata?.point || [];

  if (extData.index != -1) {
    // 更新 points 数组 - 这是关键修复！
    allData.value[0].points[extData.index] = lnglat;

    // 检查 lineData 是否存在且有数据
    if (allData.value[0].lineData && allData.value[0].lineData.length > 0) {
      // 更新不同位置的线
      // 链接线
      if (extData.index == 0) {
        // 拖动航线首点
        if (allData.value[0].lineData[0]) {
          allData.value[0].lineData[0].geometry.coordinates[0] = lnglat;
          // 更新距离属性
          const distance = calculateDistance(
            lnglat,
            allData.value[0].lineData[0].geometry.coordinates[1]
          );
          allData.value[0].lineData[0].properties.distance = distance;
        }

        // 更新起飞点到航点一的连接线终点高度，确保同步
        if (points2.length > 0 && allData.value[0].startdata.lineData) {
          allData.value[0].startdata.lineData.geometry.coordinates[1] = lnglat;
          // 更新起飞点连接线距离
          const startDistance = calculateDistance(
            allData.value[0].startdata.lineData.geometry.coordinates[0],
            lnglat
          );
          allData.value[0].startdata.lineData.properties.distance =
            startDistance;
        }
        // 航点1拖动时，只更新连接线，不修改起飞点本身
      } else if (extData.index == allData.value[0].lineData.length) {
        // 拖动航线末点
        if (allData.value[0].lineData[extData.index - 1]) {
          allData.value[0].lineData[extData.index - 1].geometry.coordinates[1] =
            lnglat;
          // 更新距离属性
          const distance = calculateDistance(
            allData.value[0].lineData[extData.index - 1].geometry
              .coordinates[0],
            lnglat
          );
          allData.value[0].lineData[extData.index - 1].properties.distance =
            distance;
        } else {
          console.error(
            "最后一个航点对应的线段不存在，索引:",
            extData.index - 1
          );
        }
      } else {
        // 中间点

        if (allData.value[0].lineData[extData.index - 1]) {
          allData.value[0].lineData[extData.index - 1].geometry.coordinates[1] =
            lnglat;
          // 更新前一段距离
          const prevDistance = calculateDistance(
            allData.value[0].lineData[extData.index - 1].geometry
              .coordinates[0],
            lnglat
          );
          allData.value[0].lineData[extData.index - 1].properties.distance =
            prevDistance;
        }

        if (allData.value[0].lineData[extData.index]) {
          allData.value[0].lineData[extData.index].geometry.coordinates[0] =
            lnglat;
          // 更新后一段距离
          const nextDistance = calculateDistance(
            lnglat,
            allData.value[0].lineData[extData.index].geometry.coordinates[1]
          );
          allData.value[0].lineData[extData.index].properties.distance =
            nextDistance;
        }
      }
    } else {
      // 当只有一个航点时，lineData 为空，但需要更新起飞点连接线
      if (points2.length > 0 && allData.value[0].startdata.lineData) {
        allData.value[0].startdata.lineData.geometry.coordinates[1] = lnglat;
        // 更新起飞点连接线距离
        const startDistance = calculateDistance(
          allData.value[0].startdata.lineData.geometry.coordinates[0],
          lnglat
        );
        allData.value[0].startdata.lineData.properties.distance = startDistance;
      }
    }

    // 更新垂直线 - 检查 guideLineData 是否存在
    if (
      allData.value[0].guideLineData &&
      allData.value[0].guideLineData[extData.index] &&
      lnglat &&
      lnglat.length >= 3
    ) {
      // 对于Point类型，只需要更新坐标和高度属性
      allData.value[0].guideLineData[extData.index].geometry.coordinates = [
        arithmetic.subtract(lnglat[0], offset),
        lnglat[1],
      ];
      // 更新高度属性
      allData.value[0].guideLineData[extData.index].properties.h = lnglat[2];
    }
  } else if (extData.index === -1) {
    // 起飞点拖动处理
    if (allData.value[0].startdata.lineData) {
      if (points.length > 0) {
        // 链接线 - 使用安全起飞高度
        const takeoffHeight =
          props.safetakeoffaltitude ||
          allData.value[0].startdata.point[2] ||
          300;

        // 更新起飞点高度数据
        allData.value[0].startdata.point = [
          lnglat[0],
          lnglat[1],
          takeoffHeight,
        ];

        allData.value[0].startdata.lineData.geometry.coordinates[0] = [
          lnglat[0],
          lnglat[1],
          takeoffHeight,
        ];
        allData.value[0].startdata.lineData.geometry.coordinates[1] = points[0];
        // 更新起飞点连接线距离
        const startDistance = calculateDistance(
          allData.value[0].startdata.lineData.geometry.coordinates[0],
          allData.value[0].startdata.lineData.geometry.coordinates[1]
        );
        allData.value[0].startdata.lineData.properties.distance = startDistance;
      }
    }

    // 更新起飞点辅助线
    if (
      allData.value[0].startdata.guideLineData &&
      lnglat &&
      lnglat.length >= 2
    ) {
      // 对于Point类型，只需要更新坐标和高度属性
      allData.value[0].startdata.guideLineData.geometry.coordinates = [
        arithmetic.subtract(lnglat[0], offset),
        lnglat[1],
      ];
      // 确保保持绿色属性
      if (!allData.value[0].startdata.guideLineData.properties) {
        allData.value[0].startdata.guideLineData.properties = {};
      }
      allData.value[0].startdata.guideLineData.properties.isStartGuideLine = true;
      allData.value[0].startdata.guideLineData.properties.h =
        props.safetakeoffaltitude || allData.value[0].startdata.point[2] || 300;
    }
  }

  // 清除旧的距离标签并重新创建
  clearDistanceMarkers();
  updateDistanceLabels();

  calculateTotalDistance(); // 在所有更新完成后重新计算距离
  // 通知父组件数据更新
  // console.log("更新数据8", allData.value);
  allData.value[0].type = "dragging";
  emit("allData", allData.value);
  emit("totalDistance", totalDistance.value);
  RenderinglineLayer();
  RenderingguideLineLayer();
  RenderingpointLayer();
};
// 更新标点高度
const updateMarkerHeight = (extData, lnglat) => {
  if (allData.value.length === 0) return;

  // 更新标记点内容，包括提示框
  const content = `<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${extData.altitude || 0}m</div>
      <div>HAE: ${extData.altitude || 0}m</div>
    </div>
    <div class="marker-index">${extData.index + 1}</div> </div>`;
  marker.setContent(content);
  // 更新提示框中的高度信息
  updateMarkerTooltipHeight(marker, extData.altitude || 0);

  // 确保标记点有悬浮提示功能
  if (!marker._hasTooltip) {
    addMarkerTooltip(marker, "航点");
    marker._hasTooltip = true;
  }

  // 更新 points 数组 - 这是关键修复！
  allData.value[0].points[extData.index] = lnglat;

  // 检查 lineData 是否存在且有数据
  if (allData.value[0].lineData && allData.value[0].lineData.length > 0) {
    // 更新不同位置的点
    if (extData.index == 0) {
      if (allData.value[0].lineData[0]) {
        allData.value[0].lineData[0].geometry.coordinates[0] = lnglat;
      }
    } else if (extData.index == allData.value[0].lineData.length) {
      if (allData.value[0].lineData[extData.index - 1]) {
        allData.value[0].lineData[extData.index - 1].geometry.coordinates[1] =
          lnglat;
      }
    } else {
      if (allData.value[0].lineData[extData.index - 1]) {
        allData.value[0].lineData[extData.index - 1].geometry.coordinates[1] =
          lnglat;
      }
      if (allData.value[0].lineData[extData.index]) {
        allData.value[0].lineData[extData.index].geometry.coordinates[0] =
          lnglat;
      }
    }
  } else {
    // 当只有一个航点时，lineData 为空，但需要更新起飞点连接线
    if (
      allData.value[0].startdata.point &&
      allData.value[0].startdata.point.length > 0 &&
      allData.value[0].startdata.lineData
    ) {
      allData.value[0].startdata.lineData.geometry.coordinates[1] = lnglat;
      // 更新起飞点连接线距离
      const startDistance = calculateDistance(
        allData.value[0].startdata.lineData.geometry.coordinates[0],
        lnglat
      );
      allData.value[0].startdata.lineData.properties.distance = startDistance;
    }
  }

  // 更新垂直线 - 检查 guideLineData 是否存在
  if (
    allData.value[0].guideLineData &&
    allData.value[0].guideLineData[extData.index] &&
    lnglat &&
    lnglat.length >= 3
  ) {
    // 对于Point类型，只需要更新坐标和高度属性
    allData.value[0].guideLineData[extData.index].geometry.coordinates = [
      arithmetic.subtract(lnglat[0], offset),
      lnglat[1],
    ];
    // 更新高度属性
    allData.value[0].guideLineData[extData.index].properties.h = lnglat[2];
  }

  // 清除旧的距离标签并重新创建
  clearDistanceMarkers();
  updateDistanceLabels();

  // 重新计算总距离
  calculateTotalDistance();
  // 通知父组件数据更新
  // console.log("更新数据9", allData.value);
  emit("allData", allData.value);
  emit("totalDistance", totalDistance.value);

  RenderinglineLayer();
  RenderingguideLineLayer();
};
// 更新距离标签
const updateDistanceLabels = () => {
  // 清除现有距离标签
  clearDistanceMarkers();

  // 检查数据结构是否存在
  if (!allData.value || allData.value.length === 0) {
    console.warn("updateDistanceLabels: allData 为空");
    return;
  }
  // 临时数组存储所有距离
  const tempDistanceArray = [];
  // 更新起飞点连接线距离标签
  if (allData.value[0].startdata?.lineData?.geometry?.coordinates) {
    const coordinates =
      allData.value[0].startdata.lineData.geometry.coordinates;
    if (coordinates && coordinates.length >= 2) {
      const [start, end] = coordinates;
      const distance = calculateDistance(start, end);
      addDistanceLabel(start, end, distance, true);
      tempDistanceArray.push(distance); // 添加到临时距离数组
    }
  }

  // 更新起始点辅助线距离标签
  if (allData.value[0].startdata?.guideLineData?.geometry?.coordinates) {
    const coordinates =
      allData.value[0].startdata.guideLineData.geometry.coordinates;
    if (coordinates && coordinates.length >= 2) {
      // 对于Point类型的辅助线，需要构造两个点来计算距离
      const groundPoint = [coordinates[0], coordinates[1], 0]; // 地面点，高度为0
      const airPoint = [
        coordinates[0] + offset, // 空中点的经度（地面点经度 + offset）
        coordinates[1], // 空中点的纬度
        allData.value[0].startdata.guideLineData.properties.h || 0, // 空中点的高度
      ];
      const distance = calculateDistance(groundPoint, airPoint);
      addDistanceLabel(groundPoint, airPoint, distance, false, true); // 添加参数表示是起始点辅助线
      tempDistanceArray.push(distance); // 添加到临时距离数组
    }
  }

  // 更新航点间线段距离标签
  if (allData.value[0].lineData && Array.isArray(allData.value[0].lineData)) {
    allData.value[0].lineData.forEach((line) => {
      if (
        line?.geometry?.coordinates &&
        line.geometry.coordinates.length >= 2
      ) {
        const [start, end] = line.geometry.coordinates;
        const distance = calculateDistance(start, end);
        addDistanceLabel(start, end, distance);
        tempDistanceArray.push(distance); // 添加到临时距离数组
      }
    });
  }

  // 更新距离数组
  distanceArray.value = tempDistanceArray;
  emit("distanceArray", distanceArray.value);
};
// 添加距离标签
const addDistanceLabel = (
  start,
  end,
  distance,
  isStartLine = false,
  isStartGuideLine = false
) => {
  // 参数验证
  if (!start || !end) {
    console.warn("addDistanceLabel: 无效的参数", { start, end, distance });
    return;
  }

  // 确保坐标点是数组格式
  if (!Array.isArray(start) || !Array.isArray(end)) {
    console.warn("addDistanceLabel: 坐标点必须是数组格式", {
      start,
      end,
      distance,
    });
    return;
  }

  // 确保有经纬度信息
  if (
    typeof start[0] !== "number" ||
    typeof start[1] !== "number" ||
    typeof end[0] !== "number" ||
    typeof end[1] !== "number"
  ) {
    console.warn("addDistanceLabel: 坐标点缺少必要的经纬度信息", {
      start: start,
      end: end,
      distance: distance,
    });
    return;
  }

  const midLng = (start[0] + end[0]) / 2;
  const midLat = (start[1] + end[1]) / 2;
  // 2D模式下距离标签高度为0，3D模式下使用真实高度
  const midHeight = currentViewMode.value ? (start[2] + end[2]) / 2 : 0;

  // 如果是起飞点辅助线，显示高度值而不是距离值
  let displayText;
  if (isStartGuideLine && allData.value[0].startdata?.point?.[2] !== undefined) {
    // 使用起飞点的实际高度值
    displayText = `${allData.value[0].startdata.point[2]}m`;
  } else {
    // 其他情况显示四舍五入的距离值
    displayText = `${Math.round(distance)}m`;
  }

  const textMarker = new AMap.Text({
    text: displayText,
    position: [midLng, midLat, midHeight],
    style: {
      "background-color": isStartGuideLine
        ? "rgba(0,213,143,0.8)"
        : "rgba(0,0,0,0.8)", // 起始点辅助线用绿色背景
      "border-radius": "4px",
      padding: "2px 6px",
      color: "#ffffff",
      "font-size": "12px",
      "font-weight": "bold",
    },
    offset: new AMap.Pixel(0, -10),
  });

  map.value.add(textMarker);

  // 存储标记以便后续清除
  if (!allData.value[0].distanceMarkers) {
    allData.value[0].distanceMarkers = [];
  }
  allData.value[0].distanceMarkers.push(textMarker);
};
// 开始高度拖动
const startHeightDrag = (marker, startY) => {
  isDraggingHeight.value = true;
  currentDraggingMarker.value = marker;
  startDragY.value = startY;
  originalHeight.value = marker.getExtData().altitude;
};

// 结束高度拖动
const endHeightDrag = () => {
  isDraggingHeight.value = false;
  currentDraggingMarker.value = null;

  // 重新计算总距离
  calculateTotalDistance();
  // 通知父组件数据更新
  // console.log("更新数据10", allData.value);
  emit("allData", allData.value);
  emit("totalDistance", totalDistance.value);
};
// 清除距离标签
const clearDistanceMarkers = () => {
  if (allData.value[0].distanceMarkers) {
    allData.value[0].distanceMarkers.forEach((marker) => {
      map.value.remove(marker);
    });
    allData.value[0].distanceMarkers = [];
  }
};
// 渲染标记点高度
const render_marker_height = (marker) => {
  // 移除之前的事件监听器，避免重复绑定
  marker.off("positionUpdate");

  marker.on("positionUpdate", function () {
    var altitude = this.getExtData().altitude || 0;
    const newPosition = [
      this.getPosition().lng,
      this.getPosition().lat,
      altitude,
    ];

    // 如果是起飞点标记，使用保存的原始位置进行检查
    const extData = this.getExtData();
    if (extData.index === -1 && window.originalTakeoffPosition) {
      const savedOriginalPosition = window.originalTakeoffPosition;
      const distanceFromSaved = Math.sqrt(
        Math.pow(newPosition[0] - savedOriginalPosition[0], 2) +
          Math.pow(newPosition[1] - savedOriginalPosition[1], 2)
      );
    }

    this.setPosition(newPosition);
  });
  marker.emit("positionUpdate");
};

// 为标记点添加悬浮提示功能
const addMarkerTooltip = (marker, markerType = "航点") => {
  // 鼠标悬浮显示高度
  marker.on("mouseover", (e) => {
    // 获取当前标记点的DOM元素
    const markerElement = marker.getContent();
    // 获取当前标记点的高度信息
    const extData = marker.getExtData();
    // 使用真实高度显示ASL/HAE，确保始终显示真实高度
    const currentAltitude =
      extData.index !== -1 && allData.value[0].points[extData.index]
        ? allData.value[0].points[extData.index][2]
        : extData.altitude || 0;
    // 如果返回的是字符串，需要先转换为DOM元素
    let domElement = null;
    if (typeof markerElement === "string") {
      // 创建临时容器来解析HTML字符串
      const tempDiv = document.createElement("div");
      tempDiv.innerHTML = markerElement;
      domElement = tempDiv.firstElementChild;
    } else if (
      markerElement &&
      typeof markerElement.querySelector === "function"
    ) {
      domElement = markerElement;
    }

    if (domElement) {
      // 在当前标记点内查找对应的提示框
      const tooltipElement = domElement.querySelector(".line-tooltip");
      if (tooltipElement) {
        // 更新提示框中的高度信息
        const aslElement = tooltipElement.querySelector("div:first-child");
        const haeElement = tooltipElement.querySelector("div:last-child");

        if (aslElement) {
          aslElement.textContent = `ASL: ${currentAltitude}m`;
        }
        if (haeElement) {
          haeElement.textContent = `HAE: ${currentAltitude}m`;
        }

        tooltipElement.style.display = "block";
        // 更新标记点内容以显示提示框
        marker.setContent(domElement.outerHTML);
      }
    }
  });

  // 鼠标离开隐藏提示框
  marker.on("mouseout", (e) => {
    // 获取当前标记点的DOM元素
    const markerElement = marker.getContent();

    // 如果返回的是字符串，需要先转换为DOM元素
    let domElement = null;
    if (typeof markerElement === "string") {
      // 创建临时容器来解析HTML字符串
      const tempDiv = document.createElement("div");
      tempDiv.innerHTML = markerElement;
      domElement = tempDiv.firstElementChild;
    } else if (
      markerElement &&
      typeof markerElement.querySelector === "function"
    ) {
      domElement = markerElement;
    }

    if (domElement) {
      // 在当前标记点内查找对应的提示框
      const tooltipElement = domElement.querySelector(".line-tooltip");
      if (tooltipElement) {
        tooltipElement.style.display = "none";
        // 更新标记点内容以隐藏提示框
        marker.setContent(domElement.outerHTML);
      }
    }
  });
};
// 渲染线段
const RenderinglineLayer = () => {
  // 更新渲染线段
  let arr = [];

  // 根据当前视图模式决定使用哪种连接线数据
  if (currentViewMode.value) {
    // 3D模式：使用真实高度的连接线
    if (allData.value.length > 0) {
      const route = allData.value[0];
      if (Array.isArray(route.lineData)) {
        arr = arr.concat(...route.lineData);
      }
      if (route.startdata?.lineData?.type) {
        arr.push(route.startdata.lineData);
      }
    }
  } else {
    // 2D模式：使用地上坐标的连接线
    if (allData.value.length > 0) {
      // 创建地上坐标的线段数据
      const groundLineData = [];

      // 处理航点之间的连接线
      if (allData.value[0].points && allData.value[0].points.length > 1) {
        for (let i = 0; i < allData.value[0].points.length - 1; i++) {
          const startPoint = allData.value[0].points[i];
          const endPoint = allData.value[0].points[i + 1];

          groundLineData.push({
            type: "Feature",
            geometry: {
              type: "LineString",
              coordinates: [
                [startPoint[0], startPoint[1], 0], // 地上坐标
                [endPoint[0], endPoint[1], 0], // 地上坐标
              ],
            },
            properties: {
              color: "#ff0000",
              weight: 3,
            },
          });
        }
      }

      // 处理起飞点到第一个航点的连接线
      if (
        allData.value[0].startdata &&
        allData.value[0].startdata.point &&
        allData.value[0].points.length > 0
      ) {
        const startPoint = allData.value[0].startdata.point;
        const firstWaypoint = allData.value[0].points[0];

        groundLineData.push({
          type: "Feature",
          geometry: {
            type: "LineString",
            coordinates: [
              [startPoint[0], startPoint[1], 0], // 地上坐标
              [firstWaypoint[0], firstWaypoint[1], 0], // 地上坐标
            ],
          },
          properties: {
            color: "#00ff00",
            weight: 3,
          },
        });
      }

      arr = groundLineData;
    }
  }

  // 检查 lineLayer 是否存在
  if (window.lineLayer) {
    window.lineLayer.setSource(
      new window.Loca.GeoJSONSource({
        data: {
          type: "FeatureCollection",
          features: arr,
        },
      })
    );
    window.lineLayer.render();
  } else {
    console.error("window.lineLayer 不存在");
  }
};
// 更新渲染辅助线(垂直线)
const RenderingguideLineLayer = () => {
  let arr = [];
  // 单航线模式：直接处理第一个航线
  if (allData.value.length > 0) {
    const route = allData.value[0];
    if (Array.isArray(route.guideLineData)) {
      arr = arr.concat(...route.guideLineData);
    }
    if (route.startdata?.guideLineData?.type) {
      arr.push(route.startdata.guideLineData);
    }
  }

  // 检查 guideLineLayer 是否存在
  if (window.guideLineLayer) {
    window.guideLineLayer.setSource(
      new window.Loca.GeoJSONSource({
        data: {
          type: "FeatureCollection",
          features: arr,
        },
      }),
      {
        unit: "meter",
        height: (index, feature) => {
          const height = feature.properties.h; // 使用高度因子，
          return height;
        },
        color: "#f0ed7a", // 白色激光线
        lineWidth: 3, // 适中的线条宽度，确保可见
        trailLength: 50000,
        repeat: 0,
      }
    );
    const currentZoom = map.value.getZoom();
    let newLineWidth;
    // 根据zoom级别设置线条粗细，zoom越大线条越细
    if (currentZoom >= 19.5) {
      newLineWidth = 0.7; // 最高级别，最细线条
    } else if (currentZoom >= 19) {
      newLineWidth = 1.0;
    } else if (currentZoom >= 18.5) {
      newLineWidth = 1.2;
    } else if (currentZoom >= 18) {
      newLineWidth = 1.6;
    } else if (currentZoom >= 17.5) {
      newLineWidth = 2.0;
    } else if (currentZoom >= 17) {
      newLineWidth = 3.0;
    } else if (currentZoom >= 16.5) {
      newLineWidth = 4.0;
    } else if (currentZoom >= 16) {
      newLineWidth = 6.0;
    } else {
      newLineWidth = 7.0; // 最低级别，最粗线条
    }

    // 重新设置辅助线样式 - 使用全局的 guideLineLayer
    if (window.guideLineLayer && allData.value.length > 0) {
      // 获取辅助线数据
      let arr = [];
      const route = allData.value[0];
      if (Array.isArray(route.guideLineData)) {
        arr = arr.concat(...route.guideLineData);
      }
      if (route.startdata?.guideLineData?.type) {
        arr.push(route.startdata.guideLineData);
      }

      // 重新设置数据源，保持静态辅助线效果并更新线条宽度
      window.guideLineLayer.setSource(
        new window.Loca.GeoJSONSource({
          data: {
            type: "FeatureCollection",
            features: arr,
          },
        }),
        {
          unit: "meter",
          height: (index, feature) => {
            return feature.properties.h || 0;
          },
          color: "#f0ed7a", // 黄色辅助线
          lineWidth: newLineWidth, // 使用新的线条宽度
          trailLength: 5000, // 设置为0，禁用流动效果
          repeat: 0, // 不重复
        }
      );
      // 重新渲染以应用新样式
      window.guideLineLayer.render();
    }
    // console.log("更新渲染垂直线", window.guideLineLayer);
    // window.guideLineLayer.render();
    // zoomChange();
  } else {
    console.error("window.guideLineLayer 不存在");
  }
};

// 底部圆点marker数组
const bottomMarkers = ref([]);

// 更新渲染圆点图层
const RenderingpointLayer = () => {
  // 清除现有的底部marker
  bottomMarkers.value.forEach((marker) => {
    map.value.remove(marker);
  });
  bottomMarkers.value = [];

  // 单航线模式：直接处理第一个航线
  if (allData.value.length > 0) {
    const route = allData.value[0];

    // 处理起飞点底部标记
    if (route.startdata && route.startdata.point && route.startdata.point.length > 0) {
      const takeoffPoint = route.startdata.point;
      const bottomMarker = new AMap.Marker({
        position: [takeoffPoint[0], takeoffPoint[1], 0], // 地面位置
        content: currentViewMode.value
          ? `<div style="width:8px;height:8px;background:#f0ed7a;border-radius:50%;border:1px solid #fff;"></div>`
          : `<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${takeoffPoint[2] || 0}m</div> 
      <div>HAE: ${takeoffPoint[2] || 0}m</div>
    </div>
    <div class="marker-index">T</div> </div>`,
        offset: currentViewMode.value
          ? new AMap.Pixel(-4, -8) // 3D模式偏移量
          : new AMap.Pixel(-15, -15), // 2D模式偏移量
        extData: {
          index: -1, // 起飞点索引为-1
          isBottomMarker: true, // 标识这是底部marker
          originalPosition: [takeoffPoint[0], takeoffPoint[1]],
          altitude: takeoffPoint[2] || 0, // 保存高度信息
        },
        draggable: true,
        zIndex: 100, // 确保在辅助线上方
      });

      // 添加起飞点底部标记的事件处理
      bottomMarker.on("dragging", (e) => {
        const extData = bottomMarker.getExtData();
        const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

        // 更新起飞点底部标记位置
        bottomMarker.setExtData(extData);

        // 更新起飞点空中坐标的经纬度，保持高度不变
        if (allData.value[0].startdata.point) {
          const currentAltitude = allData.value[0].startdata.point[2];
          allData.value[0].startdata.point = [
            newPosition[0],
            newPosition[1],
            currentAltitude,
          ];
        }

        // 更新起飞点空中marker位置和originalPosition
        if (allData.value[0].startdata.marker) {
          const airMarker = allData.value[0].startdata.marker;
          const airExtData = airMarker.getExtData();
          airExtData.originalPosition = [newPosition[0], newPosition[1]];
          airMarker.setExtData(airExtData);
          airMarker.setPosition([
            newPosition[0],
            newPosition[1],
            allData.value[0].startdata.point[2],
          ]);
        }

        // 更新辅助线
        updateLineAndGuideLine(
          [
            newPosition[0],
            newPosition[1],
            allData.value[0].startdata.point?.[2] || 0,
          ],
          extData
        );

        // 立即重新渲染激光线图层，确保拖动时可见
        if (window.guideLineLayer) {
          RenderingguideLineLayer();
        }

        // 如果是2D模式，更新底部标记的样式和偏移量
        if (!currentViewMode.value) {
          const point = allData.value[0].startdata.point;
          bottomMarker.setContent(`<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${point[2] || 0}m</div>
      <div>HAE: ${point[2] || 0}m</div>
    </div>
    <div class="marker-index">T</div> </div>`);
          bottomMarker.setOffset(new AMap.Pixel(-15, -15));
        }
      });

      map.value.add(bottomMarker);
      bottomMarkers.value.push(bottomMarker);
    }

    if (Array.isArray(route.points)) {
      // 为每个航点创建地面圆点marker
      route.points.forEach((point, index) => {
        const bottomMarker = new AMap.Marker({
          position: [point[0], point[1], 0], // 地面位置
          content: currentViewMode.value
            ? `<div style="width:8px;height:8px;background:#f0ed7a;border-radius:50%;border:1px solid #fff;"></div>`
            : `<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${point[2] || 0}m</div> 
      <div>HAE: ${point[2] || 0}m</div>
    </div>
    <div class="marker-index">${index + 1}</div> </div>`,
          offset: currentViewMode.value
            ? new AMap.Pixel(-4, -8) // 3D模式偏移量
            : new AMap.Pixel(-15, -15), // 2D模式偏移量
          extData: {
            index: index,
            isBottomMarker: true, // 标识这是底部marker
            originalPosition: [point[0], point[1]],
            altitude: point[2] || 0, // 保存高度信息
          },
          draggable: true,
          zIndex: 100, // 确保在辅助线上方
        });

        // 添加鼠标悬停事件 - 显示拖动光标
        bottomMarker.on("mouseover", (e) => {
          if (map.value) {
            map.value.getContainer().style.cursor = "move";
          }
        });

        bottomMarker.on("mouseout", (e) => {
          if (map.value) {
            // 恢复默认光标样式
            if (drawing_mode.value == 2) {
              map.value.getContainer().style.cursor = "crosshair";
            } else {
              map.value.getContainer().style.cursor = isDrawing.value
                ? "crosshair"
                : "default";
            }
          }
        });

        // 添加拖动事件
        bottomMarker.on("dragging", (e) => {
          const extData = bottomMarker.getExtData();
          const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

          // 更新底部坐标 - 不更新originalPosition，避免影响高度调整
          bottomMarker.setExtData(extData);

          // 更新空中坐标的经纬度，保持高度不变
          if (extData.index !== -1 && allData.value[0].points[extData.index]) {
            const currentAltitude = allData.value[0].points[extData.index][2];
            allData.value[0].points[extData.index] = [
              newPosition[0],
              newPosition[1],
              currentAltitude,
            ];
          } else if (extData.index === -1 && allData.value[0].startdata.point) {
            const currentAltitude = allData.value[0].startdata.point[2];
            allData.value[0].startdata.point = [
              newPosition[0],
              newPosition[1],
              currentAltitude,
            ];
          }

          // 更新空中marker位置和originalPosition
          if (extData.index !== -1 && allData.value[0].markers[extData.index]) {
            const airMarker = allData.value[0].markers[extData.index];
            const airExtData = airMarker.getExtData();
            airExtData.originalPosition = [newPosition[0], newPosition[1]];
            airMarker.setExtData(airExtData);
            airMarker.setPosition([
              newPosition[0],
              newPosition[1],
              allData.value[0].points[extData.index][2],
            ]);
          } else if (
            extData.index === -1 &&
            allData.value[0].startdata.marker
          ) {
            const airMarker = allData.value[0].startdata.marker;
            const airExtData = airMarker.getExtData();
            airExtData.originalPosition = [newPosition[0], newPosition[1]];
            airMarker.setExtData(airExtData);
            airMarker.setPosition([
              newPosition[0],
              newPosition[1],
              allData.value[0].startdata.point[2],
            ]);
          }

          // 更新辅助线
          updateLineAndGuideLine(
            [
              newPosition[0],
              newPosition[1],
              allData.value[0].points[extData.index]?.[2] ||
                allData.value[0].startdata.point[2],
            ],
            extData
          );

          // 立即重新渲染激光线图层，确保拖动时可见
          if (window.guideLineLayer) {
            RenderingguideLineLayer();
          }

          // 如果是2D模式，更新底部标记的样式和偏移量
          if (!currentViewMode.value) {
            const point =
              extData.index !== -1
                ? allData.value[0].points[extData.index]
                : allData.value[0].startdata.point;
            bottomMarker.setContent(`<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${point[2] || 0}m</div>
      <div>HAE: ${point[2] || 0}m</div>
    </div>
    <div class="marker-index">${
      extData.index === -1 ? "T" : extData.index + 1
    }</div> </div>`);
            bottomMarker.setOffset(new AMap.Pixel(-15, -15));

            // 重新添加tooltip功能
            addMarkerTooltip(bottomMarker, "航点");

            // 重新添加右键删除事件
            bottomMarker.on("rightclick", (e) => {
              showDeleteButtonHandler(e, extData.index);
            });
          }
        });

        // 添加拖动结束事件，确保2D模式下保持正确的偏移量
        bottomMarker.on("dragend", (e) => {
          if (!currentViewMode.value) {
            // 2D模式下确保偏移量正确
            bottomMarker.setOffset(new AMap.Pixel(-15, -15));
          }
        });

        // 为底部标记添加tooltip功能
        addMarkerTooltip(bottomMarker, "航点");

        // 为底部标记添加双击事件 - 只在2D模式下添加
        if (!currentViewMode.value) {
          bottomMarker.on("dblclick", (e) => {
            // 双击事件 - 将航点数据传给父元素
            const position = bottomMarker.getPosition();
            const extData = bottomMarker.getExtData();
            const waypointData = {
              lng: position.lng,
              lat: position.lat,
              altitude: allData.value[0].points[extData.index]
                ? allData.value[0].points[extData.index][2]
                : 0,
              index: extData.index,
            };

            // 发送给父组件
            emit("waypointDoubleClick", waypointData);
          });
        }

        // 为底部标记添加右键删除事件
        bottomMarker.on("rightclick", (e) => {
          showDeleteButtonHandler(e, index);
        });
        map.value.add(bottomMarker);
        bottomMarkers.value.push(bottomMarker);
      });
    }
  }
};

// 2D模式：重新绘制连接线，使用地上坐标（高度为0）
const updateLineHeightFor2D = () => {
  if (allData.value.length > 0) {
    // 创建地上坐标的线段数据
    const groundLineData = [];

    // 处理航点之间的连接线
    if (allData.value[0].points && allData.value[0].points.length > 1) {
      for (let i = 0; i < allData.value[0].points.length - 1; i++) {
        const startPoint = allData.value[0].points[i];
        const endPoint = allData.value[0].points[i + 1];

        groundLineData.push({
          type: "Feature",
          geometry: {
            type: "LineString",
            coordinates: [
              [startPoint[0], startPoint[1], 0], // 地上坐标
              [endPoint[0], endPoint[1], 0], // 地上坐标
            ],
          },
          properties: {
            color: "#ff0000",
            weight: 3,
          },
        });
      }
    }

    // 处理起飞点到第一个航点的连接线
    if (
      allData.value[0].startdata &&
      allData.value[0].startdata.point &&
      allData.value[0].points.length > 0
    ) {
      const startPoint = allData.value[0].startdata.point;
      const firstWaypoint = allData.value[0].points[0];

      groundLineData.push({
        type: "Feature",
        geometry: {
          type: "LineString",
          coordinates: [
            [startPoint[0], startPoint[1], 0], // 地上坐标
            [firstWaypoint[0], firstWaypoint[1], 0], // 地上坐标
          ],
        },
        properties: {
          color: "#00ff00",
          weight: 3,
        },
      });
    }

    // 更新线段图层
    if (window.lineLayer) {
      window.lineLayer.setSource(
        new window.Loca.GeoJSONSource({
          data: {
            type: "FeatureCollection",
            features: groundLineData,
          },
        })
      );
      window.lineLayer.render();
    }
  }

  // 确保更新底部标记
  RenderingpointLayer();
};

// 3D模式：重新绘制连接线，使用真实高度
const updateLineHeightFor3D = () => {
  if (allData.value.length > 0) {
    // 重新构建线段数据以恢复真实高度
    rebuildLineData();
    RenderinglineLayer();
  }
};

// 显示删除按钮
const showDeleteButtonHandler = (event, waypointIndex) => {
  // 通过标记点的位置找到对应的航点索引
  let actualIndex = -1;
  if (event && event.target) {
    // 从事件目标（标记点）获取位置
    const markerPosition = event.target.getPosition();
    const markerLng = markerPosition.lng;
    const markerLat = markerPosition.lat;

    // 在航点数组中查找匹配的航点
    for (let i = 0; i < allData.value[0].points.length; i++) {
      const point = allData.value[0].points[i];
      if (
        Math.abs(point[0] - markerLng) < 0.000001 &&
        Math.abs(point[1] - markerLat) < 0.000001
      ) {
        actualIndex = i;
        break;
      }
    }
  } else {
    // 如果无法从事件获取位置，使用传入的索引（兼容旧版本）
    actualIndex = waypointIndex;
  }

  // 获取航点的3D坐标，参考距离标签的定位方式
  const waypoint = allData.value[0].points[actualIndex];
  if (!waypoint) {
    console.error(
      "未找到航点数据，索引:",
      actualIndex,
      "总航点数:",
      allData.value[0].points.length
    );
    return;
  }
  // 用鼠标事件的位置来定位删除按钮
  if (event && event.pixel) {
    // 直接使用鼠标点击的像素位置
    selectedWaypointIndex.value = actualIndex;
    deleteButtonPosition.value = {
      x: event.pixel.x + 20, // 向右偏移10像素
      y: event.pixel.y - 10, // 使用鼠标点击的Y坐标
    };
  }
  showDeleteButton.value = true;
};

// 隐藏删除按钮
const hideDeleteButton = () => {
  showDeleteButton.value = false;
};

// 删除航点
const deleteWaypoint = () => {
  hasUserInteracted.value = true; // 标记用户已进行交互
  if (selectedWaypointIndex.value >= 0 && allData.value.length > 0) {
    const index = selectedWaypointIndex.value;
    // 移除航点
    allData.value[0].points.splice(index, 1);
    // 移除标记点
    if (allData.value[0].markers[index]) {
      map.value.remove(allData.value[0].markers[index]);
      allData.value[0].markers.splice(index, 1);
    }
    // 移除对应的底部marker
    if (bottomMarkers.value[index]) {
      map.value.remove(bottomMarkers.value[index]);
      bottomMarkers.value.splice(index, 1);
    }
    // 移除辅助线
    if (allData.value[0].guideLineData[index]) {
      allData.value[0].guideLineData.splice(index, 1);
    }
    // 重新构建线段数据
    rebuildLineData();
    // 更新所有标记点的索引
    updateMarkerIndexes();
    // 清除距离标签并重新创建
    clearDistanceMarkers();
    updateDistanceLabels();
    // 重新计算总距离
    calculateTotalDistance();
    // 通知父组件数据更新
    // console.log("更新数据11", allData.value);
    emit("allData", allData.value);
    emit("totalDistance", totalDistance.value);
    // 重新渲染
    RenderinglineLayer();
    RenderingguideLineLayer();
    RenderingpointLayer();
    ElMessage.success("航点删除成功");
  }

  hideDeleteButton();
  selectedWaypointIndex.value = -1;
};

// 防抖版本的数据更新函数
const debouncedEmitAllData = () => {
  // 清除之前的定时器
  if (dataUpdateDebounceTimer) {
    clearTimeout(dataUpdateDebounceTimer);
  }
  
  // 设置新的防抖定时器
  dataUpdateDebounceTimer = setTimeout(() => {
    emit("allData", allData.value);
    emit("totalDistance", totalDistance.value);
  }, DATA_UPDATE_DEBOUNCE_DELAY);
};

// 更新防抖版本的总距离更新函数
const debouncedEmitTotalDistance = (distance) => {
  // 清除之前的定时器
  if (dataUpdateDebounceTimer) {
    clearTimeout(dataUpdateDebounceTimer);
  }
  
  // 设置新的防抖定时器
  dataUpdateDebounceTimer = setTimeout(() => {
    emit("totalDistance", distance);
  }, DATA_UPDATE_DEBOUNCE_DELAY);
};

// 重新构建线段数据
const rebuildLineData = () => {
  if (allData.value.length === 0) return;

  // 确保 allData 有正确的结构
  if (!allData.value[0].points) {
    allData.value[0].points = [];
  }
  if (!allData.value[0].startdata) {
    allData.value[0].startdata = {
      point: null,
      lineData: null,
      guideLineData: null,
      marker: null,
    };
  }

  const points = allData.value[0].points;
  const newLineData = [];

  // 重新构建航点间的线段
  for (let i = 0; i < points.length - 1; i++) {
    newLineData.push({
      type: "Feature",
      geometry: {
        type: "LineString",
        coordinates: [
          [points[i][0], points[i][1], points[i][2]],
          [points[i + 1][0], points[i + 1][1], points[i + 1][2]],
        ],
      },
      properties: {
        color: "#3366ff",
        distance: calculateDistance(points[i], points[i + 1]),
      },
    });
  }

  allData.value[0].lineData = newLineData;

  // 重新构建航点辅助线 - 改为Point类型
  const newGuideLineData = [];
  for (let i = 0; i < points.length; i++) {
    // 检查points[i]是否存在且包含必要的坐标
    if (points[i] && points[i].length >= 3) {
      newGuideLineData.push({
        type: "Feature",
        geometry: {
          type: "Point",
          coordinates: [
            arithmetic.subtract(points[i][0], offset),
            points[i][1],
          ], // 地面点坐标
        },
        properties: {
          color: "#f4ed7c",
          h: points[i][2], // 使用h属性，与mapvvvv.html保持一致
        },
      });
    }
  }
  allData.value[0].guideLineData = newGuideLineData;

  // 重新构建起始点连接线和辅助线
  if (
    allData.value[0].startdata.point &&
    allData.value[0].startdata.point.length > 0
  ) {
    if (points.length > 0) {
      // 保持起飞点的经纬度不变，高度使用安全起飞高度
      const originalLng = allData.value[0].startdata.point[0];
      const originalLat = allData.value[0].startdata.point[1];
      const takeoffHeight =
        props.safetakeoffaltitude || allData.value[0].startdata.point[2] || 300;
      allData.value[0].startdata.point = [
        originalLng,
        originalLat,
        takeoffHeight,
      ];

      // 如果有航点，连接到第一个航点
      allData.value[0].startdata.lineData = {
        type: "Feature",
        geometry: {
          type: "LineString",
          coordinates: [allData.value[0].startdata.point, points[0]],
        },
        properties: {
          color: "#3366ff",
          distance: calculateDistance(
            allData.value[0].startdata.point,
            points[0]
          ),
        },
      };

      // 重新构建起始点辅助线 - 改为Point类型
      if (
        allData.value[0].startdata.point &&
        allData.value[0].startdata.point.length >= 3
      ) {
        allData.value[0].startdata.guideLineData = {
          type: "Feature",
          geometry: {
            type: "Point",
            coordinates: [
              arithmetic.subtract(allData.value[0].startdata.point[0], offset),
              allData.value[0].startdata.point[1],
            ], // 地面点坐标
          },
          properties: {
            isStartGuideLine: true, // 添加标识，表示这是起始点辅助线
            h: allData.value[0].startdata.point[2], // 使用h属性，与mapvvvv.html保持一致
          },
        };
      }
    } else {
      // 如果没有航点，清除起始点连接线，但保留辅助线
      allData.value[0].startdata.lineData = null;

      // 重新构建起始点辅助线 - 即使没有航点也要保留
      if (
        allData.value[0].startdata.point &&
        allData.value[0].startdata.point.length >= 3
      ) {
        allData.value[0].startdata.guideLineData = {
          type: "Feature",
          geometry: {
            type: "Point",
            coordinates: [
              arithmetic.subtract(allData.value[0].startdata.point[0], offset),
              allData.value[0].startdata.point[1],
            ], // 地面点坐标
          },
          properties: {
            isStartGuideLine: true, // 添加标识，表示这是起始点辅助线
            h: allData.value[0].startdata.point[2], // 使用h属性，与mapvvvv.html保持一致
          },
        };
      }
    }
  }

  // 更新圆点图层
  RenderingpointLayer();
};

// 更新标记点索引
const updateMarkerIndexes = () => {
  if (allData.value.length === 0) return;

  allData.value[0].markers.forEach((marker, index) => {
    const extData = marker.getExtData();
    extData.index = index;
    marker.setExtData(extData);

    // 更新标记点内容（编号），保持提示框结构
    const content = `<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${extData.altitude || 0}m</div>
      <div>HAE: ${extData.altitude || 0}m</div>
    </div>
    <div class="marker-index">${index + 1}</div> </div>`;
    marker.setContent(content);
    // 更新提示框中的高度信息
    updateMarkerTooltipHeight(marker, extData.altitude || 0);
  });

  // 确保更新底部标记
  RenderingpointLayer();
};

// 更新特定航点的坐标
const updateWaypointCoordinate = (waypointIndex, longitude, latitude) => {
  try {
    // 验证参数
    if (
      waypointIndex === undefined ||
      waypointIndex === null ||
      waypointIndex < 0 ||
      waypointIndex >= allData.value[0].points.length
    ) {
      console.error("无效的航点索引:", waypointIndex);
      return;
    }

    if (isNaN(longitude) || isNaN(latitude)) {
      console.error("经纬度格式无效");
      return;
    }

    // 验证经纬度范围
    if (longitude < -180 || longitude > 180) {
      console.error("经度范围应在-180~180之间");
      return;
    }

    if (latitude < -90 || latitude > 90) {
      console.error("纬度范围应在-90~90之间");
      return;
    }

    // 更新航点坐标
    const currentPoint = allData.value[0].points[waypointIndex];
    const originalHeight = currentPoint[2] || 300; // 保持原有高度
    allData.value[0].points[waypointIndex] = [
      longitude,
      latitude,
      originalHeight,
    ];

    // 更新对应的标记点位置
    if (allData.value[0].markers && allData.value[0].markers[waypointIndex]) {
      const marker = allData.value[0].markers[waypointIndex];
      marker.setPosition([longitude, latitude]);

      // 更新标记点的扩展数据
      const extData = marker.getExtData();
      extData.originalPosition = [longitude, latitude];
      marker.setExtData(extData);

      // 重新渲染标记点高度
      render_marker_height(marker);
    }

    // 重新构建线段数据
    rebuildLineData();

    // 更新距离标签
    clearDistanceMarkers();
    updateDistanceLabels();

    // 重新计算总距离
    calculateTotalDistance();

    // 重新渲染图层
    RenderinglineLayer();
    RenderingguideLineLayer();
    // console.log("更新数据12", allData.value);
    emit("allData", allData.value);
    emit("totalDistance", totalDistance.value);
    emit("waypointCoordinateUpdated", {
      waypointIndex,
      longitude,
      latitude,
      height: originalHeight,
    });
  } catch (error) {
    console.error("更新航点坐标时出错:", error);
  }
};
// 更新标记点提示框中的高度信息
const updateMarkerTooltipHeight = (marker, newHeight) => {
  const markerElement = marker.getContent();

  // 如果返回的是字符串，需要先转换为DOM元素
  let domElement = null;
  if (typeof markerElement === "string") {
    // 创建临时容器来解析HTML字符串
    const tempDiv = document.createElement("div");
    tempDiv.innerHTML = markerElement;
    domElement = tempDiv.firstElementChild;
  } else if (
    markerElement &&
    typeof markerElement.querySelector === "function"
  ) {
    domElement = markerElement;
  }

  if (domElement) {
    // 在当前标记点内查找对应的提示框
    const tooltipElement = domElement.querySelector(".line-tooltip");
    if (tooltipElement) {
      // 更新提示框中的高度信息
      const aslElement = tooltipElement.querySelector("div:first-child");
      const haeElement = tooltipElement.querySelector("div:last-child");

      if (aslElement) {
        aslElement.textContent = `ASL: ${newHeight}m`;
      }
      if (haeElement) {
        haeElement.textContent = `HAE: ${newHeight}m`;
      }

      // 更新标记点内容
      marker.setContent(domElement.outerHTML);
    }
  }
};
// 局部更新函数
const updateSingleLine = (extData, newCoords) => {
  if (allData.value.length === 0) return;

  // 判断是起飞点线段还是航线线段
  if (extData.index == -1) {
    allData.value[0].startdata.lineData.geometry.coordinates = newCoords; // 更新起飞点连接线
  } else {
    allData.value[0].lineData[extData.index].geometry.coordinates = newCoords; // 更新航线线段
  }

  // 仅更新特定线段而不是整个图层
  lineLayer.getSource().setData({
    type: "FeatureCollection",
    features: getMergedLineFeatures(),
  });
  lineLayer.render();
};
// 计算整数化倍数：
const integerOperation = (val1, val2) => {
  // 添加参数验证
  if (
    val1 === undefined ||
    val1 === null ||
    val2 === undefined ||
    val2 === null
  ) {
    console.error("integerOperation: 参数不能为undefined或null", {
      val1,
      val2,
    });
    return 1; // 返回默认值
  }

  const val1DecimalIndex = val1.toString().indexOf("."); // 获取数值1的小数位的长度
  const len1 =
    val1DecimalIndex === -1 ? 0 : val1.toString().length - val1DecimalIndex - 1;
  const val2DecimalIndex = val2.toString().indexOf("."); // 获取数值2的小数位的长度
  const len2 =
    val2DecimalIndex === -1 ? 0 : val2.toString().length - val2DecimalIndex - 1;
  const p = Math.max(len1, len2); // 获取大的小数位数
  return Math.pow(10, p); // Math.pow() 计算一个数的指定次幂的方法 10的p次方
};
// 解决浮点数运算的精度
const arithmetic = {
  add(val1, val2) {
    const p = integerOperation(val1, val2);
    return (val1 * p + val2 * p) / p;
  },
  subtract(val1, val2) {
    const p = integerOperation(val1, val2);
    return (val1 * p - val2 * p) / p;
  },
  multiply(val1, val2) {
    const p = integerOperation(val1, val2);
    return (val1 * p * (val2 * p)) / (p * p);
  },
  division(val1, val2) {
    const p = integerOperation(val1, val2);
    return (val1 * p) / (val2 * p) / (p * p);
  },
};
// 监听地图视图变化
const initRotationListeners = () => {
  if (!map.value) return;
  // 监听地图视图变化
  map.value.on("viewchange", () => {
    const rotation = map.value.getRotation();
    const pitch = map.value.getPitch();
    rotationAngle.value = rotation;
    // 监听pitch变化：如果当前是2D模式且pitch不为0，自动切换到3D模式
    if (
      !currentViewMode.value &&
      pitch !== 0 &&
      !isAutoSwitching.value &&
      previousPitch.value === 0
    ) {
      isAutoSwitching.value = true; // 设置自动切换标志
      getviewClick(true, pitch); // 切换到3D模式
      // 延迟重置标志，避免循环
      setTimeout(() => {
        isAutoSwitching.value = false;
      }, 1000);
    }
    previousPitch.value = pitch; // 更新previousPitch值（保留用于调试）
  });
};
// 回到地图中心点
const getviewcenterClick = () => {
  map.value.setCenter(defaultCenter);
};

// 获取地图视角 2d 3d
const getviewClick = (value, pitch) => {
  isAutoSwitching.value = true; // 设置自动切换标志，防止循环
  map.value.setPitch(value ? (pitch ? pitch : 50) : 0);

  // 如果是切换到2D模式，立即重置pitch值
  if (!value) {
    previousPitch.value = 0;
  }
  // 更新当前视图模式状态
  currentViewMode.value = value;
  // 根据2D/3D模式控制标点显示和辅助线显示
  if (!value) {
    // 2D模式：隐藏空中航点，只显示地上航点，隐藏辅助线
    rotationAngle.value = 0;
    previousPitch.value = 0; // 重置pitch值
    if (allData.value.length > 0) {
      // 隐藏所有空中航点标记
      if (allData.value[0].markers && allData.value[0].markers.length > 0) {
        allData.value[0].markers.forEach((marker) => {
          marker.hide();
        });
      }

      // 显示所有底部圆点marker（地上航点）
      bottomMarkers.value.forEach((marker) => {
        if (marker && marker.show) {
          // 2D模式下显示带index的样式
          const extData = marker.getExtData();
          marker.setContent(`<div style="position:relative;">
    <div class="line-tooltip">
      <div>ASL: ${extData.altitude || 0}m</div>
      <div>HAE: ${extData.altitude || 0}m</div>
    </div>
    <div class="marker-index">${
      extData.index === -1 ? "T" : extData.index + 1
    }</div> </div>`);
          marker.setOffset(new AMap.Pixel(-15, -15));

          // 添加tooltip功能
          addMarkerTooltip(marker, "航点");

          // 添加双击事件 - 2D模式下重新添加双击事件
          marker.on("dblclick", (e) => {
            // 双击事件 - 将航点数据传给父元素
            const position = marker.getPosition();
            const waypointData = {
              lng: position.lng,
              lat: position.lat,
              altitude: allData.value[0].points[extData.index]
                ? allData.value[0].points[extData.index][2]
                : 0,
              index: extData.index,
            };

            // 发送给父组件
            emit("waypointDoubleClick", waypointData);
          });

          // 添加右键删除事件
          marker.on("rightclick", (e) => {
            showDeleteButtonHandler(e, extData.index);
          });

          marker.show();
        }
      });
    }

    // 隐藏辅助线图层
    if (window.guideLineLayer) {
      window.guideLineLayer.hide();
    }

    // 重新绘制连接线，使用地上坐标（高度为0）
    updateLineHeightFor2D();

    // 重新更新距离标签，2D模式下高度为0
    updateDistanceLabels();
  } else {
    // 3D模式：显示空中航点，隐藏地上航点，显示辅助线
    previousPitch.value = map.value.getPitch(); // 记录3D模式的pitch值
    if (allData.value.length > 0) {
      // 显示所有空中航点标记
      if (allData.value[0].markers && allData.value[0].markers.length > 0) {
        allData.value[0].markers.forEach((marker) => {
          marker.show();
        });
      }

      // 显示起飞点标记
      if (allData.value[0].startdata && allData.value[0].startdata.marker) {
        allData.value[0].startdata.marker.show();
      }

      // 隐藏所有底部圆点marker
      bottomMarkers.value.forEach((marker) => {
        if (marker && marker.hide) {
          // 3D模式下恢复简单圆点样式
          marker.setContent(
            `<div style="width:8px;height:8px;background:#f0ed7a;border-radius:50%;border:1px solid #fff;"></div>`
          );
          marker.setOffset(new AMap.Pixel(-4, -8));
          marker.hide();
        }
      });
    }

    // 显示辅助线图层
    if (window.guideLineLayer) {
      window.guideLineLayer.show();
    }

    // 重新绘制连接线，使用真实高度
    updateLineHeightFor3D();

    // 重新更新距离标签，3D模式下使用真实高度
    updateDistanceLabels();
  }

  // 延迟重置自动切换标志
  setTimeout(() => {
    isAutoSwitching.value = false;
  }, 500);
};
// 获取地图尺寸
const getmapsizeClick = (operation) => {
  if (map.value) {
    let currentZoom = map.value.getZoom(); // 获取当前地图缩放级别
    const zoomChange = operation === "add" ? 0.1 : -0.1; // 每次点击缩放变化量，可根据需要调整
    map.value.setZoomAndCenter(currentZoom + zoomChange, map.value.getCenter()); // 设置新的缩放级别，同时保持当前地图中心不变
  }
};
// 检查图层是否存在的辅助函数
const hasLayer = (className) => {
  if (!map.value) return false;
  const layers = map.value.getLayers();
  return layers.some((layer) => layer.CLASS_NAME === className);
};

// 移除指定类型的图层
const removeLayerByType = (className) => {
  if (!map.value) return;
  const layers = map.value.getLayers();
  layers.forEach((layer) => {
    if (layer.CLASS_NAME === className) {
      map.value.remove(layer);
    }
  });
};

// 获取地图类型
const getmapTypeClick = (type) => {
  if (type.type == 1) {
    // 标准地图
    if (!hasLayer("AMap.TileLayer")) {
      map.value.add(new AMap.TileLayer());
      // 设置标准地图的 features
      map.value.setFeatures(["bg", "building", "road", "point"]);
    }
  } else {
    // 移除标准地图图层
    if (hasLayer("AMap.TileLayer")) {
      removeLayerByType("AMap.TileLayer");
    }
    // 卫星地图-天地图
    if (!hasLayer("AMap.TileLayer.Satellite")) {
      map.value.add(satelliteLayer.value);
    }
    if (type.road) {
      if (!hasLayer("AMap.TileLayer.RoadNet")) {
        map.value.add(roadNetLayer.value);
      }
    } else {
      if (hasLayer("AMap.TileLayer.RoadNet")) {
        removeLayerByType("AMap.TileLayer.RoadNet");
      }
    }
  }
};

// 设置一次起飞点
const oneSetTakeoffMode = () => {
  // 确保 allData 有正确的结构
  if (!allData.value || allData.value.length === 0) {
    allData.value = [
      {
        points: [],
        lineData: [],
        guideLineData: [],
        startdata: {
          point: null,
          lineData: null,
          guideLineData: null,
          marker: null,
        },
      },
    ];
  }

  // 确保 startdata 存在
  if (!allData.value[0].startdata) {
    allData.value[0].startdata = {
      point: null,
      lineData: null,
      guideLineData: null,
      marker: null,
    };
  }

  drawing_mode.value = 2; //起飞点设置
  isDrawing.value = true;
  // 禁用双击放大功能，防止在设置起飞点时意外放大地图
  if (map.value) {
    map.value.setStatus({
      doubleClickZoom: false,
    });
  }
  // map.value.getContainer().style.cursor = "crosshair"; // 设置鼠标样式
  map.value.setCursor("crosshair");

  // 先移除可能存在的地图点击监听器，再添加新的
  map.value.off("click", handleMapClickForTakeoff);
  map.value.on("click", handleMapClickForTakeoff);
};

// 起飞点设置（重设模式）
const enterSetTakeoffMode = () => {
  drawing_mode.value = 2; //起飞点设置

  isDrawing.value = true;
  isFirstTimeTakeoff.value = false; // 重设模式不是首次设置
  isResetMode.value = true; // 标记为重设模式
  map.value.getContainer().style.cursor = "crosshair"; // 设置鼠标样式

  // 禁用双击放大功能，防止在设置起飞点时意外放大地图
  if (map.value) {
    map.value.setStatus({
      doubleClickZoom: false,
    });
  }

  // 确保 allData 有正确的结构
  if (!allData.value || allData.value.length === 0) {
    allData.value = [
      {
        points: [],
        lineData: [],
        guideLineData: [],
        startdata: {
          point: null,
          lineData: null,
          guideLineData: null,
          marker: null,
        },
      },
    ];
  }

  // 确保 startdata 存在
  if (!allData.value[0].startdata) {
    allData.value[0].startdata = {
      point: null,
      lineData: null,
      guideLineData: null,
      marker: null,
    };
  }

  // 重设模式下不立即清除现有起飞点，保持可见直到用户点击新位置
  // 先移除可能存在的地图点击监听器，再添加新的
  map.value.off("click", handleMapClickForTakeoff);
  map.value.on("click", handleMapClickForTakeoff);
};

// 在地图上点击设置起飞点
const handleMapClickForTakeoff = (e) => {
  // 如果有默认数据且不在绘制模式下，不执行重设起飞点
  if (
    props.drawDefaultRoute &&
    props.drawDefaultRoute.length > 0 &&
    !isDrawing.value
  ) {
    return;
  }

  hasUserInteracted.value = true; // 标记用户已进行交互
  const lnglat = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);
  const defaultHeight = props.safetakeoffaltitude || 300; // 使用安全起飞高度
  const takeoffPosition = [lnglat[0], lnglat[1], defaultHeight];

  // 确保 allData 有正确的结构
  if (!allData.value || allData.value.length === 0) {
    allData.value = [
      {
        points: [],
        lineData: [],
        guideLineData: [],
        startdata: {
          point: null,
          lineData: null,
          guideLineData: null,
          marker: null,
        },
      },
    ];
  }

  // 确保 startdata 存在
  if (!allData.value[0].startdata) {
    allData.value[0].startdata = {
      point: null,
      lineData: null,
      guideLineData: null,
      marker: null,
    };
  }

  // 完全清除现有的起飞点
  if (allData.value[0].startdata.marker) {
    map.value.remove(allData.value[0].startdata.marker);
    allData.value[0].startdata.marker = null;
  }

  // 清除起飞点相关数据
  allData.value[0].startdata.point = null;
  allData.value[0].startdata.lineData = null;
  allData.value[0].startdata.guideLineData = null;

  // 立即重新渲染以清除旧的视觉效果
  RenderinglineLayer();
  RenderingguideLineLayer();
  RenderingpointLayer();

  // 清除距离标签
  clearDistanceMarkers();

  // 重新计算总距离
  calculateTotalDistance();

  // 创建新的起飞点标记
  const takeoffMarker = new AMap.Marker({
    position: [lnglat[0], lnglat[1]],
    content: `<div style="display:flex;align-items:center;justify-content:center;width:30px;height:30px;font-weight:bold;color:white;background:#fff;border-radius:50%;"><img src="/static/flay.png" width="24" height="24" /></div>`,
    offset: new AMap.Pixel(-20, -20),
    extData: {
      altitude: 0, // 起飞点标记保持在地面
      index: -1,
      originalPosition: [lnglat[0], lnglat[1]],
    },
    draggable: true,
  });

  map.value.add(takeoffMarker);

  // 重设起飞点时，暂时禁用位置保护逻辑
  const oldOriginalTakeoffPosition = window.originalTakeoffPosition;
  window.originalTakeoffPosition = null; // 暂时清除，避免位置保护

  render_marker_height(takeoffMarker);

  // 恢复原始位置，但使用新的位置
  window.originalTakeoffPosition = [lnglat[0], lnglat[1]];

  allData.value[0].startdata.marker = takeoffMarker;

  // 保存起飞点的原始位置，用于后续保护
  const originalTakeoffPosition = [lnglat[0], lnglat[1]];
  window.originalTakeoffPosition = originalTakeoffPosition;

  // 更新起飞点坐标
  allData.value[0].startdata.point = takeoffPosition;

  // 创建起飞点辅助线 - 改为Point类型
  if (lnglat) {
    allData.value[0].startdata.guideLineData = {
      type: "Feature",
      geometry: {
        type: "Point",
        coordinates: [arithmetic.subtract(lnglat[0], offset), lnglat[1]], // 地面点坐标
      },
      properties: {
        color: "#00d58f",
        isStartGuideLine: true,
        h: defaultHeight, // 使用h属性，与mapvvvv.html保持一致
      },
    };
  }

  // 如果有航点，创建起飞点连接线
  if (allData.value[0].points && allData.value[0].points.length > 0) {
    allData.value[0].startdata.lineData = {
      type: "Feature",
      geometry: {
        type: "LineString",
        coordinates: [
          takeoffPosition, // 起飞点
          allData.value[0].points[0], // 第一个航点
        ],
      },
      properties: {
        color: "#3366ff",
        distance: calculateDistance(
          takeoffPosition,
          allData.value[0].points[0]
        ),
      },
    };
  }

  // 添加起飞点鼠标悬停事件 - 显示拖动光标
  takeoffMarker.on("mouseover", (e) => {
    if (map.value) {
      map.value.getContainer().style.cursor = "move";
    }
  });

  takeoffMarker.on("mouseout", (e) => {
    if (map.value) {
      // 恢复默认光标样式
      if (drawing_mode.value == 2) {
        map.value.getContainer().style.cursor = "crosshair";
      } else {
        map.value.getContainer().style.cursor = isDrawing.value
          ? "crosshair"
          : "default";
      }
    }
  });

  // 添加起飞点拖动事件
  takeoffMarker.on("dragstart", (e) => {
    // 拖动开始时设置光标为move
    if (map.value) {
      map.value.getContainer().style.cursor = "move";
    }
  });

  takeoffMarker.on("dragging", (e) => {
    const extData = takeoffMarker.getExtData();
    const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);

    // 起飞点只支持正常拖动，不支持高度调整
    extData.originalPosition = [newPosition[0], newPosition[1]];
    takeoffMarker.setExtData(extData);

    // 使用安全起飞高度，而不是extData.altitude
    const takeoffHeight =
      props.safetakeoffaltitude || allData.value[0].startdata.point[2] || 300;
    allData.value[0].startdata.point = [
      newPosition[0],
      newPosition[1],
      takeoffHeight,
    ];

    updateLineAndGuideLine(
      [newPosition[0], newPosition[1], takeoffHeight],
      extData
    );
  });

  takeoffMarker.on("dragend", (e) => {
    // 拖动结束时恢复光标样式
    if (map.value) {
      if (drawing_mode.value == 2) {
        map.value.getContainer().style.cursor = "crosshair";
      } else {
        map.value.getContainer().style.cursor = isDrawing.value
          ? "crosshair"
          : "default";
      }
    }

    // 使用防抖发送数据更新事件
  debouncedEmitAllData();
  debouncedEmitTotalDistance(totalDistance.value);
  });

  // 重新渲染图层
  RenderinglineLayer();
  RenderingguideLineLayer();

  // 更新距离标签
  clearDistanceMarkers();
  updateDistanceLabels();

  // 重新计算总距离
  calculateTotalDistance();
  // console.log("更新数据13", allData.value);
  // 通知父组件数据更新
  emit("allData", allData.value);
  emit("totalDistance", totalDistance.value);

  // 根据当前模式决定调用哪个退出函数
  // 检查是否是首次设置起飞点
  if (isFirstTimeTakeoff.value) {
    // 首次设置模式
    isFirstTimeTakeoff.value = false; // 标记不再是首次设置
    exitoneSetTakeoffMode();
  } else {
    // 重设模式 - 成功设置新起飞点后，通知父组件退出重设模式
    emit("delSetTakeoffMode", true);
    // 直接退出，不调用exitSetTakeoffMode避免重复发送事件
    isDrawing.value = false;
    drawing_mode.value = 1; // 重置为航线绘制模式
    map.value.getContainer().style.cursor = "default"; // 恢复鼠标样式
    map.value.off("click", handleMapClickForTakeoff); // 移除地图点击监听
  }
};

//绘制默认航线
// const getDrawDefaultRoute = (airlineform) => {
//   let wayPoints = airlineform.wayPoints; //航点
//   let takeOffRefPoint = airlineform.takeOffRefPoint.split(","); //起飞点坐标
//   takeOffRefPoint = [
//     parseFloat(takeOffRefPoint[0]),
//     parseFloat(takeOffRefPoint[1]),
//   ];
//   let takeOffRefHeight = airlineform.takeOffSecurityHeight; //起飞点高度
//   pointsList.value = wayPoints.map((item) => {
//     return {
//       lng: item.longitude,
//       lat: item.latitude,
//       height: item.height,
//     };
//   });
//   startdata.value.point = takeOffRefPoint;
//   startdata.value.point[2] = takeOffRefHeight;
//   map.value.setCenter(takeOffRefPoint); //设置地图中心点
//   createGroundMarker(wayPoints); //创建航点
//   renderGuideLine(wayPoints); //渲染辅助线
// };
// // 创建标记映射表
// const groundMarkerMap = ref(new Map()); // 存储 index -> 地面标记 的映射
// const flightMarkerMap = ref(new Map()); // 存储 index -> 空中标记 的映射
// //传入经纬度转换为数字
const lnglatToNumber = (lng, lat) => {
  return [Number(lng.toFixed(12)), Number(lat.toFixed(12))];
};
// //数据渲染航点
// const createGroundMarker = (wayPoints) => {
//   //如果是编辑
//   if (route.query.id) {
//     wayPoints.forEach((item, index) => {
//       const marker = new AMap.Marker({
//         position: [item.longitude, item.latitude, 0],
//         content: `<div class="ground-marker"></div>`,
//         offset: new AMap.Pixel(0, 0),
//         draggable: true, //启用拖拽
//         extData: {
//           altitude: 0, // 起飞点标记保持在地面
//           index: index,
//           originalPosition: [item.longitude, item.latitude, 0],
//         },
//       });
//       const markerFlay = new AMap.Marker({
//         position: [item.longitude, item.latitude, item.height],
//         content: `<div class="ground-marker-flay">${index + 1}</div>`,
//         offset: new AMap.Pixel(0, 0),
//         // draggable: true, //启用拖拽
//         extData: {
//           altitude: item.height, // 空中航点高度
//           index: index,
//           originalPosition: [item.longitude, item.latitude, item.height],
//         },
//       });
//       // 保存映射关系
//       groundMarkerMap.value.set(index, marker);
//       flightMarkerMap.value.set(index, markerFlay);
//       map.value.add(marker);
//       map.value.add(markerFlay);
//       groundMarkerDrag(marker); //拖拽航点
//       // airMarkerDrag(markerFlay); //拖拽航点
//     });
//   }
// };

// //地下航点拖拽
// const groundMarkerDrag = (marker) => {
//   //鼠标变move mouseover 鼠标移入
//   marker.on("mouseover", (e) => {
//     if (map.value) {
//       map.value.getContainer().style.cursor = "move";
//     }
//   });
//   marker.on("mouseout", (e) => {
//     if (map.value) {
//       map.value.getContainer().style.cursor = "default";
//     }
//   });
//   marker.on("dragging", (e) => {
//     if (map.value) {
//       map.value.getContainer().style.cursor = "move";
//     }
//     updateDragData(marker, e, "ground");
//   });
//   marker.on("dragend", (e) => {
//     if (map.value) {
//       map.value.getContainer().style.cursor = "default";
//     }
//     // marker.off("dragging");
//   });
// };
// //更新拖拽数据
// const updateDragData = (marker, e, type) => {
//   //更新航点坐标
//   const extData = marker.getExtData();
//   const newPosition = lnglatToNumber(e.lnglat.KL, e.lnglat.kT);
//   extData.originalPosition = [newPosition[0], newPosition[1], 0];
//   marker.setExtData(extData);

//   // 更新 pointsList 中对应索引的坐标
//   if (extData.index !== undefined && extData.index >= 0) {
//     pointsList.value[extData.index] = {
//       ...pointsList.value[extData.index],
//       lng: newPosition[0],
//       lat: newPosition[1],
//     };

//     const flightMarker = flightMarkerMap.value.get(extData.index);
//     if (flightMarker) {
//       const height = pointsList.value[extData.index].height || 0;
//       flightMarker.setPosition([newPosition[0], newPosition[1], height]);
//     }
//   }
// };
// //渲染辅助线
// const renderGuideLine = (wayPoints) => {
//   if (route.query.id) {
//     wayPoints.forEach((item, index) => {
//       const guideLine = new AMap.Polyline({
//         path: [
//           [item.longitude, item.latitude, 0],
//           [item.longitude, item.latitude, item.height],
//         ],
//         strokeColor: "#00d58f",
//         strokeWeight: 2,
//       });
//       map.value.add(guideLine);
//     });
//   }
// };

// 退出"首次设置起飞点"模式
const exitoneSetTakeoffMode = () => {
  isExitingFirstTimeMode.value = true; // 标记正在退出首次设置模式
  hasUserInteracted.value = true; // 标记用户已进行交互
  isFirstTimeTakeoff.value = false; // 标记不再是首次设置

  // 发送事件通知父组件
  emit("deloneSetTakeoffMode", false);

  // 恢复双击放大功能
  if (map.value) {
    map.value.setStatus({
      doubleClickZoom: true,
    });
  }

  // 延迟设置 isDrawing = false，确保 watch 不会重新设置
  setTimeout(() => {
    isDrawing.value = false;
    drawing_mode.value = 1; // 重置为航线绘制模式
    map.value.getContainer().style.cursor = "default"; // 恢复鼠标样式
    map.value.off("click", handleMapClickForTakeoff); // 移除地图点击监听
    isExitingFirstTimeMode.value = false; // 重置标志
  }, 0);
};
// 起飞点提示显示逻辑
const shouldShowTakeoffTip = computed(() => {
  // 在重设模式下不显示提示
  if (isResetMode.value) {
    return false;
  }
  
  // 检查是否有起飞点数据（包括默认数据）
  const hasTakeoffPoint =
    allData.value[0]?.startdata?.point &&
    allData.value[0]?.startdata?.point.length > 0;
  const hasTakeoffMarker = allData.value[0]?.startdata?.marker;
  
  // 检查是否有航点数据
  const hasWaypoints = allData.value[0]?.points && allData.value[0]?.points.length > 0;
  
  // 如果已经有起飞点或航点，不显示提示
  if (hasTakeoffPoint || hasTakeoffMarker || hasWaypoints) {
    return false;
  }
  
  // 对于编辑航线的情况，即使有默认数据，如果还没有设置起飞点，也应该显示提示
  if (props.drawDefaultRoute && props.drawDefaultRoute.length > 0) {
    // 检查默认数据中是否有起飞点
    const defaultRoute = props.drawDefaultRoute[0];
    const hasDefaultTakeoffPoint = defaultRoute?.startdata?.point && 
      defaultRoute.startdata.point.length > 0;
    
    // 如果默认数据中没有起飞点，则显示提示
    return !hasDefaultTakeoffPoint;
  }
  
  // 默认情况下，如果没有起飞点和航点，显示提示
  return true;
});
// 监听起飞点提示的显示状态，自动开启地图点击事件
watch(shouldShowTakeoffTip, (newVal) => {
  // 在重设模式下，不执行任何操作
  if (isResetMode.value) {
    return;
  }

  // 如果正在退出首次设置模式，不执行任何操作
  if (isExitingFirstTimeMode.value) {
    return;
  }

  // 如果已经不是首次设置起飞点，不执行任何操作
  if (!isFirstTimeTakeoff.value) {
    return;
  }

  // 如果有默认数据，不启用绘制模式
  if (props.drawDefaultRoute && props.drawDefaultRoute.length > 0) {
    return;
  }

  // 如果用户已经手动设置了绘制状态，不要自动修改
  // if (hasUserInteracted.value) {
  //   return;
  // }

  if (newVal && map.value) {
    // 显示提示时，设置 isDrawing = true 和 drawing_mode = 2
    // 这样既可以绘制航点，也可以设置起飞点


    isDrawing.value = true;
    drawing_mode.value = 2; // 起飞点设置模式
    map.value.getContainer().style.cursor = "crosshair";
    
    // 确保添加起飞点点击监听器
    map.value.off("click", handleMapClickForTakeoff);
    map.value.on("click", handleMapClickForTakeoff);
  } else if (!newVal && map.value) {
    // 隐藏提示时，恢复默认状态（仅在没有默认数据时）
    if (!props.drawDefaultRoute || props.drawDefaultRoute.length === 0) {
      isDrawing.value = false;
      drawing_mode.value = 1; // 重置为航线绘制模式
      map.value.getContainer().style.cursor = "default";
      map.value.off("click", handleMapClickForTakeoff);
    }
  }
});

// 退出"设置起飞点"模式
const exitSetTakeoffMode = () => {
  // 只有在非重设模式下才发送事件（避免重复发送）
  if (props.flayShow !== false) {
    emit("delSetTakeoffMode", true);
  }
  isDrawing.value = false;
  drawing_mode.value = 1; // 重置为航线绘制模式
  isResetMode.value = false; // 退出重设模式

  // 恢复双击放大功能
  if (map.value) {
    map.value.setStatus({
      doubleClickZoom: true,
    });
  }

  map.value.getContainer().style.cursor = "default"; // 恢复鼠标样式
  map.value.off("click", handleMapClickForTakeoff); // 移除地图点击监听
};
// 监听起飞点高度变化
watch(
  () => props.flightaltitude,
  (newVal, oldVal) => {
    // 保存旧的高度模式
    const oldMode = previousHeightMode.value;
    // 更新之前的高度模式
    previousHeightMode.value = newVal;
    // 更新默认高度
    setDefaultHeightByMode();
    // 更新现有航点的高度，传入旧的高度模式
    updateExistingPointsHeight(oldMode);
  }
);
// 监听安全起飞高度变化
watch(
  () => props.safetakeoffaltitude,
  (newVal, oldVal) => {
    // 更新现有起飞点的高度
    if (
      allData.value.length > 0 &&
      allData.value[0].startdata &&
      allData.value[0].startdata.point
    ) {
      // 更新起飞点高度

      allData.value[0].startdata.point[2] = newVal;
      // 更新起飞点标记的高度显示
      if (allData.value[0].startdata.marker) {
        const extData = allData.value[0].startdata.marker.getExtData();
        extData.altitude = 0; // 起飞点标记保持在地面
        allData.value[0].startdata.marker.setExtData(extData);
        render_marker_height(allData.value[0].startdata.marker);
      }

      // 更新起飞点辅助线
      if (allData.value[0].startdata.guideLineData) {
        // 对于Point类型，更新高度属性
        allData.value[0].startdata.guideLineData.properties.h = newVal;
      }

      // 重新构建线段数据
      rebuildLineData();
      // 更新距离标签
      clearDistanceMarkers();
      updateDistanceLabels();
      // 重新计算总距离
      calculateTotalDistance();
      // 通知父组件数据更新
      // console.log("更新数据14", allData.value);
      emit("allData", allData.value);
      emit("totalDistance", totalDistance.value);
      // 重新渲染
      RenderinglineLayer();
      RenderingguideLineLayer();
    } else {
    }
  }
);

// 监听默认航线数据变化
watch(
  () => props.drawDefaultRoute,
  (newVal, oldVal) => {
    if (newVal && newVal[0] && isMapInitialized.value) {
      // 检查是否有航点数据或起飞点数据
      const hasPoints = (newVal[0].points && newVal[0].points.length > 0) ||
                       (newVal[0].point && newVal[0].point.length > 0);
      const hasTakeoffPoint = newVal[0].startdata && newVal[0].startdata.point && 
                             newVal[0].startdata.point.length > 0;
      
      // 只有在有数据的情况下才绘制
      if (hasPoints || hasTakeoffPoint) {
        // 确保地图完全加载后再绘制
        setTimeout(() => {
          drawDefaultRoute(newVal[0]);
        }, 500);
      }
    }
  },
  { immediate: false } // 不要立即执行，等待地图初始化完成
);

// 防抖定时器
let airlineListUpdateTimer = null;
// 添加数据更新防抖定时器
let dataUpdateDebounceTimer = null;
const DATA_UPDATE_DEBOUNCE_DELAY = 300; // 300ms防抖延迟

// 监听航点列表变化，更新地图上的航点高度
watch(
  () => props.airlineList,
  (newVal, oldVal) => {
    // 如果有默认数据且不在绘制模式下，只允许高度更新，不允许其他更新
    if (
      props.drawDefaultRoute &&
      props.drawDefaultRoute.length > 0 &&
      !isDrawing.value
    ) {
      // 检查是否只是高度变化，如果是则允许更新
      let hasHeightChanges = false;
      if (oldVal && newVal && oldVal.length === newVal.length) {
        for (let i = 0; i < newVal.length; i++) {
          if (oldVal[i] && newVal[i] && oldVal[i].height !== newVal[i].height) {
            hasHeightChanges = true;
            break;
          }
        }
      }

      if (!hasHeightChanges) {
        return;
      }
    }

    // 清除之前的定时器
    if (airlineListUpdateTimer) {
      clearTimeout(airlineListUpdateTimer);
    }

    // 设置防抖延迟
    airlineListUpdateTimer = setTimeout(() => {
      if (
        allData.value.length > 0 &&
        allData.value[0].points &&
        allData.value[0].points.length > 0 &&
        newVal &&
        newVal.length > 0
      ) {
        let hasChanges = false;

        // 更新每个航点的高度
        newVal.forEach((waypoint, index) => {
          if (index < allData.value[0].points.length) {
            const oldHeight = allData.value[0].points[index][2];
            const newHeight = waypoint.height || 0;

            if (oldHeight !== newHeight) {
              // 更新航点坐标的高度（真实数据）
              allData.value[0].points[index][2] = newHeight;

              // 更新对应标记点的高度显示
              if (allData.value[0].markers && allData.value[0].markers[index]) {
                const marker = allData.value[0].markers[index];
                const extData = marker.getExtData();
                extData.altitude = newHeight;
                marker.setExtData(extData);
                render_marker_height(marker);
              }

              hasChanges = true;
            }
          }
        });

        // 只有在有实际变化时才更新地图
        if (hasChanges) {
          // 更新距离标签
          clearDistanceMarkers();
          updateDistanceLabels();
          // 重新计算总距离
          calculateTotalDistance();

          // 根据当前视图模式重新渲染
          if (currentViewMode.value) {
            // 3D模式：使用真实高度
            rebuildLineData();
            RenderinglineLayer();
            RenderingguideLineLayer();
          } else {
            // 2D模式：使用地上坐标
            updateLineHeightFor2D();
            // 隐藏辅助线
            if (window.guideLineLayer) {
              window.guideLineLayer.hide();
            }
          }
        }
      }
    }, 100); // 100ms 防抖延迟
  },
  { deep: true } // 深度监听，监听数组内部对象的变化
);

// 专门监听航点高度变化的监听器
watch(
  () => props.airlineList?.map((wp) => wp.height),
  (newHeights, oldHeights) => {
    // 如果有高度变化，强制更新地图
    if (
      newHeights &&
      oldHeights &&
      JSON.stringify(newHeights) !== JSON.stringify(oldHeights)
    ) {
      // 延迟执行，确保其他更新完成
      setTimeout(() => {
        if (allData.value.length > 0 && allData.value[0].points) {
          newHeights.forEach((height, index) => {
            if (
              index < allData.value[0].points.length &&
              height !== undefined
            ) {
              const oldHeight = allData.value[0].points[index][2];
              if (oldHeight !== height) {
                allData.value[0].points[index][2] = height;

                // 更新对应标记点的高度显示
                if (
                  allData.value[0].markers &&
                  allData.value[0].markers[index]
                ) {
                  const marker = allData.value[0].markers[index];
                  const extData = marker.getExtData();
                  extData.altitude = height;
                  marker.setExtData(extData);
                  render_marker_height(marker);
                }
              }
            }
          });

          // 重新渲染地图
          if (currentViewMode.value) {
            rebuildLineData();
            RenderinglineLayer();
            RenderingguideLineLayer();
          } else {
            updateLineHeightFor2D();
          }
        }
      }, 200);
    }
  },
  { deep: true }
);
//监听航线表单变化
// watch(
//   () => props.airlineform,
//   (newVal, oldVal) => {
//     if (newVal) {
//       console.log("航线表单", newVal);
//       getDrawDefaultRoute(newVal);
//     }
//   }
// );

// 生命周期
onMounted(async () => {
  await initMap(); // 初始化地图
  // 如果编辑航线，则设置加载状态
  // if (route.query.id) {
  //   isLoadingDefaultRoute.value = true;
  // }
  // 初始化之前的高度模式
  previousHeightMode.value = props.flightaltitude;
  // 根据高度模式设置默认高度
  setDefaultHeightByMode();
  
  // 地图初始化完成后，如果有默认航线数据，触发绘制
  if (props.drawDefaultRoute && 
      props.drawDefaultRoute[0] && 
      ((props.drawDefaultRoute[0].points && props.drawDefaultRoute[0].points.length > 0) ||
       (props.drawDefaultRoute[0].point && props.drawDefaultRoute[0].point.length > 0))) {
    isLoadingDefaultRoute.value = true;
    // 等待地图初始化完成后再绘制
    const checkAndDraw = () => {
      if (isMapInitialized.value) {
        drawDefaultRoute(props.drawDefaultRoute[0]);
      } else {
        setTimeout(checkAndDraw, 100);
      }
    };
    setTimeout(checkAndDraw, 500);
  }
  
  // 地图初始化完成后，手动检查是否需要显示起飞点提示
  // 使用 nextTick 确保 DOM 更新完成
  nextTick(() => {
    if (shouldShowTakeoffTip.value && map.value) {
      isDrawing.value = true;
      drawing_mode.value = 2; // 起飞点设置模式
      map.value.getContainer().style.cursor = "crosshair";
      
      // 确保添加起飞点点击监听器
      map.value.off("click", handleMapClickForTakeoff);
      map.value.on("click", handleMapClickForTakeoff);
    }
  });

  // 添加点击其他地方隐藏删除按钮的事件
  document.addEventListener("click", (e) => {
    if (!e.target.closest(".delete-button")) {
      hideDeleteButton();
    }
  });
  // 添加鼠标按下事件，如果鼠标不在删除按钮上就隐藏删除按钮
  document.addEventListener("mousedown", (e) => {
    if (!e.target.closest(".delete-button")) {
      hideDeleteButton();
    }
  });
});

onBeforeUnmount(() => {
  // 清理地图
  if (map.value) {
    // 重置鼠标光标样式
    map.value.getContainer().style.cursor = "default";
    map.value.destroy();
  }
  if (window.airportMarkers && window.airportMarkers.length > 0) {
    window.airportMarkers.forEach((marker) => {
      if (map.value) {
        map.value.remove(marker);
      }
    });
    window.airportMarkers = [];
  }

  // 清理事件监听
  window.removeEventListener("keydown", handleKeyDown);
  window.removeEventListener("keyup", handleKeyUp);

  // 清理 AMap 事件监听器
  // if (autoComplete.value) {
  //   autoComplete.value.off("select", selectHandler);
  // }

  // if (placeSearch.value) {
  //   placeSearch.value.off("markerClick", clickMarkerHandler);
  // }
});

// 根据高度模式设置默认高度
const setDefaultHeightByMode = () => {
  // 现在 flightaltitude 是具体的数值，直接使用
  defaultHeight = props.flightaltitude || 300; // 使用传入的高度值，默认300米
};

// 更新现有航点的高度 - 基于差值调整而不是直接覆盖
const updateExistingPointsHeight = (oldHeightMode) => {
  if (allData.value.length === 0) return;

  // 获取旧的高度模式对应的默认高度
  const getOldDefaultHeight = (oldMode) => {
    // 现在 oldMode 是具体的数值，直接返回
    return oldMode || 300;
  };
  // 计算高度差值
  const oldDefaultHeight = getOldDefaultHeight(oldHeightMode);
  const heightDiff = defaultHeight - oldDefaultHeight;

  // 更新起飞点高度 - 起飞点始终使用新的默认高度
  if (
    allData.value[0].startdata.point &&
    allData.value[0].startdata.point.length > 0
  ) {
    // 只有当没有设置安全起飞高度时，才使用默认高度
    if (!props.safetakeoffaltitude || props.safetakeoffaltitude <= 0) {
      allData.value[0].startdata.point[2] = defaultHeight;
    } else {
      // 如果设置了安全起飞高度，保持使用安全起飞高度

      allData.value[0].startdata.point[2] = props.safetakeoffaltitude;
    }

    // 更新起飞点标记的高度显示
    if (allData.value[0].startdata.marker) {
      const extData = allData.value[0].startdata.marker.getExtData();
      extData.altitude = 0; // 起飞点标记保持在地面
      allData.value[0].startdata.marker.setExtData(extData);
      render_marker_height(allData.value[0].startdata.marker);
    }
  }

  // 遍历所有航点，基于差值调整高度
  if (allData.value[0].points && allData.value[0].points.length > 0) {
    allData.value[0].points.forEach((point, index) => {
      // 检查该航点是否跟随航线高度（heightFollow为1表示跟随）
      // 只有当heightFollow为1时才更新高度
      const heightFollow = props.airlineList && props.airlineList[index] ? 
        props.airlineList[index].heightFollow : 1; // 默认为1（跟随）
      
      if (heightFollow === 1) {
        // 获取当前航点的高度
        const currentHeight = point[2] || oldDefaultHeight;

        // 计算航点相对于默认高度的差值
        const pointDiff = currentHeight - oldDefaultHeight;

        // 新高度 = 新默认高度 + 航点原有的差值
        const newHeight = defaultHeight + pointDiff;

        // 更新航点高度
        point[2] = newHeight;

        // 更新对应标记点的高度显示
        if (allData.value[0].markers && allData.value[0].markers[index]) {
          const marker = allData.value[0].markers[index];
          const extData = marker.getExtData();
          extData.altitude = newHeight;
          marker.setExtData(extData);
          render_marker_height(marker);
        }
      }
      // 如果heightFollow不为1，则不处理该航点的高度
    });
  }

  // 重新构建线段数据
  rebuildLineData();
  // 更新距离标签
  clearDistanceMarkers();
  updateDistanceLabels();
  // 重新计算总距离
  calculateTotalDistance();
  // 通知父组件数据更新
  // console.log("更新数据15", allData.value);
  emit("allData", allData.value);
  emit("totalDistance", totalDistance.value);

  // 重新渲染
  RenderinglineLayer();
  RenderingguideLineLayer();
};

// 辅助函数：根据索引查找标记
const findMarkerByIndex = (index) => {
  if (!allData.value || !allData.value.length > 0) return null;
  // 查找航点数据
  const waypointData = allData.value[0].markers.find(
    (item, idx) => idx === index
  );
  if (!waypointData) return null;
  if (allData.value[0].markers && allData.value[0].markers[index]) {
    return allData.value[0].markers[index];
  }
  return null;
};

// 监听起飞点设置事件
watch(
  () => props.flayoneShow,
  (newVal, oldVal) => {
    if (newVal === false) {
      // 进入起飞点设置模式
      oneSetTakeoffMode();
    }
  }
);

// 监听起飞点重设事件
watch(
  () => props.flayShow,
  (newVal, oldVal) => {
    if (newVal === false) {
      // 进入重设起飞点模式
      enterSetTakeoffMode();
    } else {
      map.value.getContainer().style.cursor = "default"; // 恢复鼠标样式
      map.value.off("click", handleMapClickForTakeoff); // 移除地图点击监听
    }
  }
);
//监听选中航点
watch(
  () => props.selectedWayPoint,
  (newVal, oldVal) => {
    if (oldVal && allData.value && allData.value.length > 0) {
      // 查找对应的航点标记
      const oldMarker = findMarkerByIndex(oldVal.index);
      if (oldMarker) {
        // 恢复默认样式 - 直接设置新的 HTML 内容
        const defaultContent = `
          <div style="position:relative;">
            <div class="line-tooltip">
              <div>ASL: ${oldVal.altitude || 0}m</div>
              <div>HAE: ${oldVal.altitude || 0}m</div>
            </div>
            <div class="marker-index">${oldVal.index + 1}</div>
          </div>
        `;
        oldMarker.setContent(defaultContent);
      }
    }
    // 设置新选中航点的颜色为蓝色
    if (newVal && allData.value && allData.value.length > 0) {
      const newMarker = findMarkerByIndex(newVal.index);
      if (newMarker) {
        // 创建带有蓝色背景的新内容
        const selectedContent = `
          <div style="position:relative;">
            <div class="line-tooltip">
              <div>ASL: ${newVal.altitude || 0}m</div>
              <div>HAE: ${newVal.altitude || 0}m</div>
            </div>
            <div class="marker-index" style="background-color: #2f69eb; color: #ffffff; border: 2px solid #ffffff;">${
              newVal.index + 1
            }</div>
          </div>
        `;
        // 设置新的内容
        newMarker.setContent(selectedContent);
        // 可选：将地图中心移动到选中的航点
        const markerPosition = newMarker.getPosition();
        // if (markerPosition) {
        //   map.value.setCenter(markerPosition);
        //   map.value.setZoom(18);
        // }
      }
    }
  }
);
// 搜索
const getsearchClick = (val) => {
  if (!val) return;
  tipInput.value = val;
  placeSearch.value.search(tipInput.value, (status, result) => {
    if (status === "complete" && result.poiList?.pois) {
      address.value = result.poiList.pois;
      mapviewRef.value.updateSearchInfo(address.value);
      if (address.value.length === 0) {
        ElMessage.info("未找到相关地点");
      }
    } else {
      const errorMsg = result?.info || "搜索失败";
      ElMessage.error(errorMsg);
      console.error("搜索出错:", errorMsg);
      address.value = [];
    }
  });
};
// 选中搜索结果
const getselectItem = (poi) => {
  const markerPosition = [poi.location.lng, poi.location.lat]; // 地图中心点
  map.value.setCenter(markerPosition);
  map.value.setZoom(16);
};

// 暴露方法给父组件使用
defineExpose({
  updateWaypointCoordinate,
  enterSetTakeoffMode,
  exitSetTakeoffMode,
});

// 清理地图资源
const cleanupMap = () => {
  if (map.value) {
    map.value.destroy();
    map.value = null;
  }
  isMapInitialized.value = false;
  // 清除可能存在的搜索定时器
  if (window.searchTimeout) {
    clearTimeout(window.searchTimeout);
    window.searchTimeout = null;
  }
};

// 组件卸载时清理
onUnmounted(cleanupMap);
</script>